home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Developers / Synthesizer Source / Synthesizer Folder / PcodeSystem.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-01  |  125.3 KB  |  2,939 lines  |  [TEXT/KAHL]
  1. /* PcodeSystem.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Synthesizer:  Digital Music Synthesis on General Purpose Computers     */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #define SHOW_ME_OPCODEREC  /* we need to see the internals of OpcodeRec */
  31. #define SHOW_ME_STACKELEMENT  /* we also need to be able to see into stack elements */
  32. #include "PcodeSystem.h"
  33. #include "Memory.h"
  34. #include "EventLoop.h"
  35. #include "DataMunging.h"
  36. #include "Alert.h"
  37. #include "FloatingPoint.h"
  38. #include "PcodeStack.h"
  39. #include "PcodeObject.h"
  40. #include "CodeCenter.h"
  41. #include "FunctionCode.h"
  42.  
  43.  
  44. /* number of pcode execution cycles between relinquish CPU calls */
  45. #if DEBUG
  46.     #define WIZZBANGCOUNTINITIALIZER (1024L) /* give us some responsiveness when debugging */
  47. #else
  48.     #define WIZZBANGCOUNTINITIALIZER (65536L)
  49. #endif
  50.  
  51.  
  52. EvalErrors                EvaluatePcode(ParamStackRec* Prep, PcodeRec* Pcode,
  53.                                         CodeCenterRec* CodeCenter, OpcodeRec** OffendingPcode,
  54.                                         long* OffendingInstruction, void* Refcon,
  55.                                         SampleErrors (*GetSampleLeftCopy)(void* Refcon, char* SampleName,
  56.                                             largefixedsigned** SampleData),
  57.                                         SampleErrors (*GetSampleRightCopy)(void* Refcon, char* SampleName,
  58.                                             largefixedsigned** SampleData),
  59.                                         SampleErrors (*GetSampleMiddleCopy)(void* Refcon, char* SampleName,
  60.                                             largefixedsigned** SampleData),
  61.                                         SampleErrors (*GetWaveTableFrameCount)(void* Refcon,
  62.                                             char* WaveTableName, long* FrameCountOut),
  63.                                         SampleErrors (*GetWaveTableTableCount)(void* Refcon,
  64.                                             char* WaveTableName, long* TableCountOut),
  65.                                         SampleErrors (*GetWaveTableCopy)(void* Refcon, char* WaveTableName,
  66.                                             largefixedsigned** WaveTableData))
  67.     {
  68.         /* machine variables */
  69.         StackElement*        Stack;
  70.         long                        StackSize;
  71.         long                        StackPtr;
  72.         long                        ProgramCounter;
  73.         OpcodeRec*            CurrentProcedure;
  74.         long                        Index;
  75.         long                        Scan;
  76.         EvalErrors            ErrorCode;
  77.         long                        WizzBangCount;
  78.         long                        FuncCallDepth;
  79.  
  80.  
  81.         /* check everything out */
  82.         ERROR(OffendingPcode == NIL,PRERR(ForceAbort,
  83.             "EvaluatePcode:  OffendingPcode is NIL"));
  84.         ERROR(OffendingInstruction == NIL,PRERR(ForceAbort,
  85.             "EvaluatePcode:  OffendingInstruction is NIL"));
  86.         CheckPtrExistence(Prep);
  87.         CheckPtrExistence(Pcode);
  88.  
  89.         /* initialize variables */
  90.         Stack = GetStackBase(Prep);
  91.         StackSize = GetStackInitialSize(Prep);
  92.         StackPtr = GetStackNumElements(Prep) - 1;
  93.         ProgramCounter = 0;
  94.         CurrentProcedure = GetOpcodeFromPcode(Pcode);
  95.         FuncCallDepth = 0;
  96.  
  97.         /* main execution loop.  this ends when there is nothing on the stack and */
  98.         /* something tries to execute a return from subroutine, which means the outermost */
  99.         /* procedure is returning.  the final return value of the program will be in P. */
  100.         WizzBangCount = WIZZBANGCOUNTINITIALIZER;
  101.         while (1)
  102.             {
  103.                 WizzBangCount -= 1;
  104.                 if (WizzBangCount == 0)
  105.                     {
  106.                         WizzBangCount = WIZZBANGCOUNTINITIALIZER;
  107.                         if (RelinquishCPUJudiciouslyCheckCancel())
  108.                             {
  109.                                 ErrorCode = eEvalUserCancelled;
  110.                                 goto ExceptionPoint;
  111.                             }
  112.                     }
  113.                 PRNGCHK(CurrentProcedure,&(CurrentProcedure[ProgramCounter].Opcode),
  114.                     sizeof(CurrentProcedure[ProgramCounter].Opcode));
  115.                 switch (CurrentProcedure[ProgramCounter++].Opcode)
  116.                     {
  117.  
  118.                         default:
  119.                             EXECUTE(PRERR(ForceAbort,"EvaluatePcode:  unknown opcode evaluated"));
  120.                             break;
  121.  
  122.                         case epFuncCallUnresolved:
  123.                             /* an unresolved function call.  try to resolve it */
  124.                             /*     -1           0               1           2             3   */
  125.                             /* <opcode> ^"<functionname>" ^[paramlist] <returntype> <reserved> */
  126.                             {
  127.                                 FuncCodeRec*        Function;
  128.                                 DataTypes*            ParameterList;
  129.                                 long                        Limit;
  130.  
  131.                                 /* special note: we can't dispose of what we get from CodeCenter */
  132.                                 /* because it gives us the real thing, not a copy */
  133.                                 PRNGCHK(CurrentProcedure,
  134.                                     &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  135.                                     sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  136.                                 Function = ObtainFunctionHandle(CodeCenter,
  137.                                     &(*(CurrentProcedure[ProgramCounter + 0].ImmediateString)),
  138.                                     StrLen(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  139.                                 if (Function == NIL)
  140.                                     {
  141.                                         ErrorCode = eEvalUndefinedFunction;
  142.                                         goto ExceptionPoint;
  143.                                     }
  144.                                 ParameterList = GetFunctionParameterTypeList(Function);
  145.                                 PRNGCHK(CurrentProcedure,
  146.                                     &(CurrentProcedure[ProgramCounter + 1].DataTypeArray),
  147.                                     sizeof(CurrentProcedure[ProgramCounter + 1].DataTypeArray));
  148.                                 Limit = PtrSize((char*)CurrentProcedure[ProgramCounter
  149.                                     + 1].DataTypeArray);
  150.                                 if (PtrSize((char*)ParameterList) != Limit)
  151.                                     {
  152.                                         /* different number of parameters */
  153.                                         ErrorCode = eEvalWrongNumParametersForFunction;
  154.                                         goto ExceptionPoint;
  155.                                     }
  156.                                 Limit = Limit / sizeof(DataTypes);
  157.                                 for (Index = 0; Index < Limit; Index += 1)
  158.                                     {
  159.                                         if (CurrentProcedure[ProgramCounter + 1].DataTypeArray[Index]
  160.                                             != ParameterList[Index])
  161.                                             {
  162.                                                 /* parameters of different types */
  163.                                                 ErrorCode = eEvalWrongParameterType;
  164.                                                 goto ExceptionPoint;
  165.                                             }
  166.                                     }
  167.                                 PRNGCHK(CurrentProcedure,
  168.                                     &(CurrentProcedure[ProgramCounter + 2].ImmediateInteger),
  169.                                     sizeof(CurrentProcedure[ProgramCounter + 2].ImmediateInteger));
  170.                                 if ((DataTypes)(CurrentProcedure[ProgramCounter + 2].ImmediateInteger)
  171.                                     != GetFunctionReturnType(Function))
  172.                                     {
  173.                                         /* different return types */
  174.                                         ErrorCode = eEvalWrongReturnType;
  175.                                         goto ExceptionPoint;
  176.                                     }
  177.                                 /* finally, the function appears to be the one we want. */
  178.                                 PRNGCHK(CurrentProcedure,
  179.                                     &(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr),
  180.                                     sizeof(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr));
  181.                                 /* first, install the PcodeRec in the instruction */
  182.                                 CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr
  183.                                     = GetOpcodeFromPcode(GetFunctionPcode(Function));
  184.                                 /* next, change the instruction to epFuncCallResolved */
  185.                                 CurrentProcedure[ProgramCounter - 1].Opcode = epFuncCallResolved;
  186.                             }
  187.                             goto epFunctionCallResolvedPoint;
  188.  
  189.                         case epFuncCallResolved:
  190.                          epFunctionCallResolvedPoint:
  191.                             /* a function call whose destination is known. */
  192.                             /*     -1           0               1           2             3    */
  193.                             /* <opcode> ^"<functionname>" ^[paramlist] <returntype> ^<OpcodeRec> */
  194.                             PRNGCHK(CurrentProcedure,
  195.                                 &(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr),
  196.                                 sizeof(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr));
  197.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 3]
  198.                                 .FunctionOpcodeRecPtr);
  199.                             StackPtr += 1;
  200.                             if (StackPtr >= StackSize)
  201.                                 {
  202.                                     StackElement*            NewStack;
  203.  
  204.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  205.                                         * sizeof(StackElement));
  206.                                     if (NewStack == NIL)
  207.                                         {
  208.                                             StackPtr -= 1;
  209.                                             ErrorCode = eEvalOutOfMemory;
  210.                                             goto ExceptionPoint;
  211.                                         }
  212.                                     Stack = NewStack;
  213.                                     StackSize += 8;
  214.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  215.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  216.                                 }
  217.                             /* store return address on stack.  the return address is the address */
  218.                             /* of the NEXT instruction. */
  219.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  220.                             Stack[StackPtr].Data.ReturnAddress.Procedure = CurrentProcedure;
  221.                             Stack[StackPtr].Data.ReturnAddress.Index
  222.                                 = ProgramCounter + 4; /* 4 words to skip */
  223.                             Stack[StackPtr].ElementType = esReturnAddress;
  224.                             /* perform the jump */
  225.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr);
  226.                             CurrentProcedure = CurrentProcedure[ProgramCounter + 3]
  227.                                 .FunctionOpcodeRecPtr;
  228.                             ProgramCounter = 0;
  229.                             /* increment function call depth counter */
  230.                             FuncCallDepth += 1;
  231.                             break;
  232.  
  233.                         case epErrorTrap:
  234.                             /*    -1            0    */
  235.                             /* <opcode> ^"<errorstring>" */
  236.                             PRNGCHK(CurrentProcedure,
  237.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  238.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  239.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  240.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  241.                                 "EvaluatePcode [epErrorTrap]:  expected scalar on stack"));
  242.                             if (Stack[StackPtr].Data.Integer == 0)
  243.                                 {
  244.                                     /* non-recoverable error -- abort */
  245.                                     (void)AskYesNoCancel("Resumable error trap encountered:  _",
  246.                                         CurrentProcedure[ProgramCounter + 0].ImmediateString,
  247.                                         "Abort","Abort",NIL);
  248.                                     ErrorCode = eEvalErrorTrapEncountered;
  249.                                     goto ExceptionPoint;
  250.                                 }
  251.                              else
  252.                                 {
  253.                                     if (AskYesNoCancel("Resumable error trap encountered:  _",
  254.                                         CurrentProcedure[ProgramCounter + 0].ImmediateString,
  255.                                         "Resume","Abort",NIL) != eYes)
  256.                                         {
  257.                                             ErrorCode = eEvalErrorTrapEncountered;
  258.                                             goto ExceptionPoint;
  259.                                         }
  260.                                 }
  261.                             ProgramCounter += 1;
  262.                             break;
  263.  
  264.                         case epBranchUnconditional:
  265.                             /*    -1            0    */
  266.                             /* <opcode> <branchoffset> */
  267.                             PRNGCHK(CurrentProcedure,
  268.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  269.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  270.                             ProgramCounter = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  271.                             break;
  272.  
  273.                         case epBranchIfZero:
  274.                             /*    -1            0    */
  275.                             /* <opcode> <branchoffset> */
  276.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  277.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  278.                                 "EvaluatePcode [epBranchIfZero]: bad stack element type"));
  279.                             if (Stack[StackPtr].Data.Integer == 0)
  280.                                 {
  281.                                     PRNGCHK(CurrentProcedure,
  282.                                         &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  283.                                         sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  284.                                     ProgramCounter = CurrentProcedure[ProgramCounter + 0]
  285.                                         .ImmediateInteger;
  286.                                 }
  287.                              else
  288.                                 {
  289.                                     ProgramCounter += 1;
  290.                                 }
  291.                             StackPtr -= 1;
  292.                             break;
  293.  
  294.                         case epBranchIfNotZero:
  295.                             /*    -1            0    */
  296.                             /* <opcode> <branchoffset> */
  297.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  298.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  299.                                 "EvaluatePcode [epBranchIfNotZero]: bad stack element type"));
  300.                             if (Stack[StackPtr].Data.Integer != 0)
  301.                                 {
  302.                                     PRNGCHK(CurrentProcedure,
  303.                                         &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  304.                                         sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  305.                                     ProgramCounter = CurrentProcedure[ProgramCounter + 0]
  306.                                         .ImmediateInteger;
  307.                                 }
  308.                              else
  309.                                 {
  310.                                     ProgramCounter += 1;
  311.                                 }
  312.                             StackPtr -= 1;
  313.                             break;
  314.  
  315.                         case epReturnFromSubroutine:
  316.                             /* - pop return address from top of stack */
  317.                             if (FuncCallDepth == 0)
  318.                                 {
  319.                                     /* if we are returning from root, then it's the end */
  320.                                     goto TotallyDonePoint;
  321.                                 }
  322.                             FuncCallDepth -= 1;
  323.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  324.                             ERROR((Stack[StackPtr].ElementType != esReturnAddress),PRERR(ForceAbort,
  325.                                 "EvaluatePcode [epReturnFromSubroutine]: Stack[0] is not a return address"));
  326.                             ProgramCounter = Stack[StackPtr].Data.ReturnAddress.Index;
  327.                             CheckPtrExistence(Stack[StackPtr].Data.ReturnAddress.Procedure);
  328.                             CurrentProcedure = Stack[StackPtr].Data.ReturnAddress.Procedure;
  329.                             EXECUTE(Stack[StackPtr].ElementType = esScalar;)
  330.                             StackPtr -= 1;
  331.                             break;
  332.  
  333.                         /* arithmetic operations */
  334.                         /* the right hand argument for binary operators is on top of stack */
  335.                         case epOperationFixedEqual:
  336.                         case epOperationIntegerEqual:
  337.                         case epOperationBooleanEqual:
  338.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  339.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  340.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  341.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  342.                                 ,PRERR(ForceAbort,
  343.                                 "EvaluatePcode [epOperationIntegerEqual]: bad stack element type"));
  344.                             Stack[StackPtr - 1].Data.Integer =
  345.                                 Stack[StackPtr - 1].Data.Integer == Stack[StackPtr].Data.Integer;
  346.                             StackPtr -= 1;
  347.                             break;
  348.                         case epOperationFixedNotEqual:
  349.                         case epOperationIntegerNotEqual:
  350.                         case epOperationBooleanNotEqual:
  351.                         case epOperationBooleanXor:
  352.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  353.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  354.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  355.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  356.                                 ,PRERR(ForceAbort,
  357.                                 "EvaluatePcode [epOperationIntegerNotEqual]: bad stack element type"));
  358.                             Stack[StackPtr - 1].Data.Integer =
  359.                                 Stack[StackPtr - 1].Data.Integer != Stack[StackPtr].Data.Integer;
  360.                             StackPtr -= 1;
  361.                             break;
  362.                         case epOperationIntegerXor:
  363.                         case epOperationFixedXor:
  364.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  365.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  366.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  367.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  368.                                 ,PRERR(ForceAbort,
  369.                                 "EvaluatePcode [epOperationIntegerXor]: bad stack element type"));
  370.                             Stack[StackPtr - 1].Data.Integer =
  371.                                 Stack[StackPtr - 1].Data.Integer ^ Stack[StackPtr].Data.Integer;
  372.                             StackPtr -= 1;
  373.                             break;
  374.                         case epOperationBooleanAnd:
  375.                         case epOperationIntegerAnd:
  376.                         case epOperationFixedAnd:
  377.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  378.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  379.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  380.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  381.                                 ,PRERR(ForceAbort,
  382.                                 "EvaluatePcode [epOperationIntegerAnd]: bad stack element type"));
  383.                             Stack[StackPtr - 1].Data.Integer =
  384.                                 Stack[StackPtr - 1].Data.Integer & Stack[StackPtr].Data.Integer;
  385.                                 /* note:  bitwise and! */
  386.                             StackPtr -= 1;
  387.                             break;
  388.                         case epOperationBooleanOr:
  389.                         case epOperationIntegerOr:
  390.                         case epOperationFixedOr:
  391.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  392.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  393.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  394.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  395.                                 ,PRERR(ForceAbort,
  396.                                 "EvaluatePcode [epOperationIntegerOr]: bad stack element type"));
  397.                             Stack[StackPtr - 1].Data.Integer =
  398.                                 Stack[StackPtr - 1].Data.Integer | Stack[StackPtr].Data.Integer;
  399.                                 /* note:  bitwise or! */
  400.                             StackPtr -= 1;
  401.                             break;
  402.                         case epOperationBooleanNot:
  403.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  404.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  405.                                 ,PRERR(ForceAbort,
  406.                                 "EvaluatePcode [epOperationBooleanNot]: bad stack element type"));
  407.                             Stack[StackPtr].Data.Integer = !Stack[StackPtr].Data.Integer;
  408.                             break;
  409.                         case epOperationIntegerNot:
  410.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  411.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  412.                                 ,PRERR(ForceAbort,
  413.                                 "EvaluatePcode [epOperationIntegerNot]: bad stack element type"));
  414.                             Stack[StackPtr].Data.Integer = ~Stack[StackPtr].Data.Integer;
  415.                             break;
  416.                         case epOperationBooleanToInteger:
  417.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  418.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  419.                                 ,PRERR(ForceAbort,
  420.                                 "EvaluatePcode [epOperationBooleanToInteger]: bad stack element type"));
  421.                             break;
  422.                         case epOperationTestFixedNegative:
  423.                         case epOperationTestIntegerNegative:
  424.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  425.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  426.                                 ,PRERR(ForceAbort,
  427.                                 "EvaluatePcode [epOperationTestIntegerNegative]: bad stack element type"));
  428.                             Stack[StackPtr].Data.Integer = (Stack[StackPtr].Data.Integer != 0);
  429.                             break;
  430.                         case epOperationTestFloatNegative:
  431.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  432.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  433.                                 ,PRERR(ForceAbort,
  434.                                 "EvaluatePcode [epOperationTestFloatNegative]: bad stack element type"));
  435.                             Stack[StackPtr].Data.Integer = (Stack[StackPtr].Data.Float != 0);
  436.                             break;
  437.                         case epOperationTestDoubleNegative:
  438.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  439.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  440.                                 ,PRERR(ForceAbort,
  441.                                 "EvaluatePcode [epOperationTestDoubleNegative]: bad stack element type"));
  442.                             Stack[StackPtr].Data.Integer = (Stack[StackPtr].Data.Double != 0);
  443.                             break;
  444.                         case epOperationGetSignFixed:
  445.                         case epOperationGetSignInteger:
  446.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  447.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  448.                                 ,PRERR(ForceAbort,
  449.                                 "EvaluatePcode [epOperationGetSignInteger]: bad stack element type"));
  450.                             if (Stack[StackPtr].Data.Integer < 0)
  451.                                 {
  452.                                     Stack[StackPtr].Data.Integer = -1;
  453.                                 }
  454.                             else if (Stack[StackPtr].Data.Integer > 0)
  455.                                 {
  456.                                     Stack[StackPtr].Data.Integer = 1;
  457.                                 }
  458.                             else
  459.                                 {
  460.                                     Stack[StackPtr].Data.Integer = 0;
  461.                                 }
  462.                             break;
  463.                         case epOperationGetSignFloat:
  464.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  465.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  466.                                 ,PRERR(ForceAbort,
  467.                                 "EvaluatePcode [epOperationGetSignFloat]: bad stack element type"));
  468.                             if (Stack[StackPtr].Data.Float < 0)
  469.                                 {
  470.                                     Stack[StackPtr].Data.Integer = -1;
  471.                                 }
  472.                             else if (Stack[StackPtr].Data.Float > 0)
  473.                                 {
  474.                                     Stack[StackPtr].Data.Integer = 1;
  475.                                 }
  476.                             else
  477.                                 {
  478.                                     Stack[StackPtr].Data.Integer = 0;
  479.                                 }
  480.                             break;
  481.                         case epOperationGetSignDouble:
  482.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  483.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  484.                                 ,PRERR(ForceAbort,
  485.                                 "EvaluatePcode [epOperationGetSignFloat]: bad stack element type"));
  486.                             if (Stack[StackPtr].Data.Double < 0)
  487.                                 {
  488.                                     Stack[StackPtr].Data.Integer = -1;
  489.                                 }
  490.                             else if (Stack[StackPtr].Data.Double > 0)
  491.                                 {
  492.                                     Stack[StackPtr].Data.Integer = 1;
  493.                                 }
  494.                             else
  495.                                 {
  496.                                     Stack[StackPtr].Data.Integer = 0;
  497.                                 }
  498.                             break;
  499.                         case epOperationIntegerToFloat:
  500.                         case epOperationBooleanToFloat:
  501.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  502.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  503.                                 ,PRERR(ForceAbort,
  504.                                 "EvaluatePcode [epOperationIntegerToFloat]: bad stack element type"));
  505.                             Stack[StackPtr].Data.Float = Stack[StackPtr].Data.Integer;
  506.                             break;
  507.                         case epOperationIntegerToDouble:
  508.                         case epOperationBooleanToDouble:
  509.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  510.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  511.                                 ,PRERR(ForceAbort,
  512.                                 "EvaluatePcode [epOperationIntegerToDouble]: bad stack element type"));
  513.                             Stack[StackPtr].Data.Double = Stack[StackPtr].Data.Integer;
  514.                             break;
  515.                         case epOperationIntegerToFixed:
  516.                         case epOperationBooleanToFixed:
  517.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  518.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  519.                                 ,PRERR(ForceAbort,
  520.                                 "EvaluatePcode [epOperationIntegerToFixed]: bad stack element type"));
  521.                             Stack[StackPtr].Data.Integer = int2largefixed(Stack[StackPtr].Data.Integer);
  522.                             break;
  523.                         case epOperationFixedNegation:
  524.                         case epOperationIntegerNegation:
  525.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  526.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  527.                                 ,PRERR(ForceAbort,
  528.                                 "EvaluatePcode [epOperationIntegerNegation]: bad stack element type"));
  529.                             Stack[StackPtr].Data.Integer = - Stack[StackPtr].Data.Integer;
  530.                             break;
  531.                         case epOperationFixedAdd:
  532.                         case epOperationIntegerAdd:
  533.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  534.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  535.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  536.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  537.                                 ,PRERR(ForceAbort,
  538.                                 "EvaluatePcode [epOperationIntegerAdd]: bad stack element type"));
  539.                             Stack[StackPtr - 1].Data.Integer =
  540.                                 Stack[StackPtr - 1].Data.Integer + Stack[StackPtr].Data.Integer;
  541.                             StackPtr -= 1;
  542.                             break;
  543.                         case epOperationFixedSubtract:
  544.                         case epOperationIntegerSubtract:
  545.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  546.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  547.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  548.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  549.                                 ,PRERR(ForceAbort,
  550.                                 "EvaluatePcode [epOperationIntegerSubtract]: bad stack element type"));
  551.                             Stack[StackPtr - 1].Data.Integer =
  552.                                 Stack[StackPtr - 1].Data.Integer - Stack[StackPtr].Data.Integer;
  553.                             StackPtr -= 1;
  554.                             break;
  555.                         case epOperationIntegerMultiply:
  556.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  557.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  558.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  559.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  560.                                 ,PRERR(ForceAbort,
  561.                                 "EvaluatePcode [epOperationIntegerMultiply]: bad stack element type"));
  562.                             Stack[StackPtr - 1].Data.Integer =
  563.                                 Stack[StackPtr - 1].Data.Integer * Stack[StackPtr].Data.Integer;
  564.                             StackPtr -= 1;
  565.                             break;
  566.                         case epOperationIntegerDivide:
  567.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  568.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  569.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  570.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  571.                                 ,PRERR(ForceAbort,
  572.                                 "EvaluatePcode [epOperationIntegerDivide]: bad stack element type"));
  573.                             if (Stack[StackPtr].Data.Integer == 0)
  574.                                 {
  575.                                     ErrorCode = eEvalDivideByZero;
  576.                                     goto ExceptionPoint;
  577.                                 }
  578.                             Stack[StackPtr - 1].Data.Integer =
  579.                                 Stack[StackPtr - 1].Data.Integer / Stack[StackPtr].Data.Integer;
  580.                             StackPtr -= 1;
  581.                             break;
  582.                         case epOperationIntegerImpreciseDivide:
  583.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  584.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  585.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  586.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  587.                                 ,PRERR(ForceAbort,
  588.                                 "EvaluatePcode [epOperationIntegerImpreciseDivide]: bad stack element type"));
  589.                             if (Stack[StackPtr].Data.Integer == 0)
  590.                                 {
  591.                                     ErrorCode = eEvalDivideByZero;
  592.                                     goto ExceptionPoint;
  593.                                 }
  594.                             Stack[StackPtr - 1].Data.Double = (double)Stack[StackPtr - 1].Data.Integer
  595.                                 / (double)Stack[StackPtr].Data.Integer;
  596.                             StackPtr -= 1;
  597.                             break;
  598.                         case epOperationIntegerModulo:
  599.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  600.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  601.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  602.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  603.                                 ,PRERR(ForceAbort,
  604.                                 "EvaluatePcode [epOperationIntegerModulo]: bad stack element type"));
  605.                             if (Stack[StackPtr].Data.Integer == 0)
  606.                                 {
  607.                                     ErrorCode = eEvalDivideByZero;
  608.                                     goto ExceptionPoint;
  609.                                 }
  610.                             Stack[StackPtr - 1].Data.Integer =
  611.                                 Stack[StackPtr - 1].Data.Integer % Stack[StackPtr].Data.Integer;
  612.                             StackPtr -= 1;
  613.                             break;
  614.                         case epOperationFixedAbs:
  615.                         case epOperationIntegerAbs:
  616.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  617.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  618.                                 ,PRERR(ForceAbort,
  619.                                 "EvaluatePcode [epOperationIntegerAbs]: bad stack element type"));
  620.                             if (Stack[StackPtr].Data.Integer < 0)
  621.                                 {
  622.                                     Stack[StackPtr].Data.Integer = - Stack[StackPtr].Data.Integer;
  623.                                 }
  624.                             break;
  625.                         case epOperationFixedShiftLeft:
  626.                         case epOperationIntegerShiftLeft:
  627.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  628.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  629.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  630.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  631.                                 ,PRERR(ForceAbort,
  632.                                 "EvaluatePcode [epOperationIntegerShiftLeft]: bad stack element type"));
  633.                             Stack[StackPtr - 1].Data.Integer =
  634.                                 Stack[StackPtr - 1].Data.Integer << Stack[StackPtr].Data.Integer;
  635.                             StackPtr -= 1;
  636.                             break;
  637.                         case epOperationFixedShiftRight:
  638.                         case epOperationIntegerShiftRight:
  639.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  640.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  641.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  642.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  643.                                 ,PRERR(ForceAbort,
  644.                                 "EvaluatePcode [epOperationIntegerShiftRight]: bad stack element type"));
  645.                             Stack[StackPtr - 1].Data.Integer =
  646.                                 Stack[StackPtr - 1].Data.Integer / (1L << Stack[StackPtr].Data.Integer);
  647.                             StackPtr -= 1;
  648.                             break;
  649.                         case epOperationFixedGreaterThan:
  650.                         case epOperationIntegerGreaterThan:
  651.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  652.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  653.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  654.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  655.                                 ,PRERR(ForceAbort,
  656.                                 "EvaluatePcode [epOperationIntegerGreaterThan]: bad stack element type"));
  657.                             Stack[StackPtr - 1].Data.Integer =
  658.                                 Stack[StackPtr - 1].Data.Integer > Stack[StackPtr].Data.Integer;
  659.                             StackPtr -= 1;
  660.                             break;
  661.                         case epOperationFixedLessThan:
  662.                         case epOperationIntegerLessThan:
  663.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  664.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  665.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  666.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  667.                                 ,PRERR(ForceAbort,
  668.                                 "EvaluatePcode [epOperationIntegerLessThan]: bad stack element type"));
  669.                             Stack[StackPtr - 1].Data.Integer =
  670.                                 Stack[StackPtr - 1].Data.Integer < Stack[StackPtr].Data.Integer;
  671.                             StackPtr -= 1;
  672.                             break;
  673.                         case epOperationFixedGreaterThanOrEqual:
  674.                         case epOperationIntegerGreaterThanOrEqual:
  675.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  676.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  677.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  678.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  679.                                 ,PRERR(ForceAbort,
  680.                                 "EvaluatePcode [epOperationIntegerGreaterThanOrEqual]: bad stack element type"));
  681.                             Stack[StackPtr - 1].Data.Integer =
  682.                                 Stack[StackPtr - 1].Data.Integer >= Stack[StackPtr].Data.Integer;
  683.                             StackPtr -= 1;
  684.                             break;
  685.                         case epOperationFixedLessThanOrEqual:
  686.                         case epOperationIntegerLessThanOrEqual:
  687.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  688.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  689.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  690.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  691.                                 ,PRERR(ForceAbort,
  692.                                 "EvaluatePcode [epOperationIntegerLessThanOrEqual]: bad stack element type"));
  693.                             Stack[StackPtr - 1].Data.Integer =
  694.                                 Stack[StackPtr - 1].Data.Integer <= Stack[StackPtr].Data.Integer;
  695.                             StackPtr -= 1;
  696.                             break;
  697.                         case epOperationFixedToBoolean:
  698.                         case epOperationIntegerToBoolean:
  699.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  700.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  701.                                 "EvaluatePcode [epOperationIntegerToBoolean]: bad stack element type"));
  702.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Integer != 0;
  703.                             break;
  704.                         case epOperationFloatAdd:
  705.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  706.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  707.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  708.                                 ,PRERR(ForceAbort,
  709.                                 "EvaluatePcode [epOperationFloatAdd]: bad stack element type"));
  710.                             Stack[StackPtr - 1].Data.Float =
  711.                                 Stack[StackPtr - 1].Data.Float + Stack[StackPtr].Data.Float;
  712.                             StackPtr -= 1;
  713.                             break;
  714.                         case epOperationFloatSubtract:
  715.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  716.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  717.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  718.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  719.                                 ,PRERR(ForceAbort,
  720.                                 "EvaluatePcode [epOperationFloatSubtract]: bad stack element type"));
  721.                             Stack[StackPtr - 1].Data.Float =
  722.                                 Stack[StackPtr - 1].Data.Float - Stack[StackPtr].Data.Float;
  723.                             StackPtr -= 1;
  724.                             break;
  725.                         case epOperationFloatNegation:
  726.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  727.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  728.                                 "EvaluatePcode [epOperationFloatNegation]: bad stack element type"));
  729.                             Stack[StackPtr].Data.Float = - Stack[StackPtr].Data.Float;
  730.                             break;
  731.                         case epOperationFloatMultiply:
  732.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  733.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  734.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  735.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  736.                                 ,PRERR(ForceAbort,
  737.                                 "EvaluatePcode [epOperationFloatMultiply]: bad stack element type"));
  738.                             Stack[StackPtr - 1].Data.Float =
  739.                                 Stack[StackPtr - 1].Data.Float * Stack[StackPtr].Data.Float;
  740.                             StackPtr -= 1;
  741.                             break;
  742.                         case epOperationFloatDivide:
  743.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  744.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  745.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  746.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  747.                                 ,PRERR(ForceAbort,
  748.                                 "EvaluatePcode [epOperationFloatDivide]: bad stack element type"));
  749.                             Stack[StackPtr - 1].Data.Float =
  750.                                 Stack[StackPtr - 1].Data.Float / Stack[StackPtr].Data.Float;
  751.                             StackPtr -= 1;
  752.                             break;
  753.                         case epOperationFloatShiftLeft:
  754.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  755.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  756.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  757.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  758.                                 ,PRERR(ForceAbort,
  759.                                 "EvaluatePcode [epOperationFloatShiftLeft]: bad stack element type"));
  760.                             Stack[StackPtr - 1].Data.Float =
  761.                                 Stack[StackPtr - 1].Data.Float * FPOWER(2,Stack[StackPtr].Data.Integer);
  762.                             StackPtr -= 1;
  763.                             break;
  764.                         case epOperationFloatShiftRight:
  765.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  766.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  767.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  768.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  769.                                 ,PRERR(ForceAbort,
  770.                                 "EvaluatePcode [epOperationFloatShiftRight]: bad stack element type"));
  771.                             Stack[StackPtr - 1].Data.Float =
  772.                                 Stack[StackPtr - 1].Data.Float * FPOWER(2,-Stack[StackPtr].Data.Integer);
  773.                             StackPtr -= 1;
  774.                             break;
  775.                         case epOperationFloatGreaterThan:
  776.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  777.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  778.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  779.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  780.                                 ,PRERR(ForceAbort,
  781.                                 "EvaluatePcode [epOperationFloatGreaterThan]: bad stack element type"));
  782.                             Stack[StackPtr - 1].Data.Integer =
  783.                                 Stack[StackPtr - 1].Data.Float > Stack[StackPtr].Data.Float;
  784.                             StackPtr -= 1;
  785.                             break;
  786.                         case epOperationFloatLessThan:
  787.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  788.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  789.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  790.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  791.                                 ,PRERR(ForceAbort,
  792.                                 "EvaluatePcode [epOperationFloatLessThan]: bad stack element type"));
  793.                             Stack[StackPtr - 1].Data.Integer =
  794.                                 Stack[StackPtr - 1].Data.Float < Stack[StackPtr].Data.Float;
  795.                             StackPtr -= 1;
  796.                             break;
  797.                         case epOperationFloatGreaterThanOrEqual:
  798.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  799.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  800.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  801.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  802.                                 ,PRERR(ForceAbort,
  803.                                 "EvaluatePcode [epOperationFloatGreaterThanOrEqual]: bad stack element type"));
  804.                             Stack[StackPtr - 1].Data.Integer =
  805.                                 Stack[StackPtr - 1].Data.Float >= Stack[StackPtr].Data.Float;
  806.                             StackPtr -= 1;
  807.                             break;
  808.                         case epOperationFloatLessThanOrEqual:
  809.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  810.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  811.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  812.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  813.                                 ,PRERR(ForceAbort,
  814.                                 "EvaluatePcode [epOperationFloatLessThanOrEqual]: bad stack element type"));
  815.                             Stack[StackPtr - 1].Data.Integer =
  816.                                 Stack[StackPtr - 1].Data.Float <= Stack[StackPtr].Data.Float;
  817.                             StackPtr -= 1;
  818.                             break;
  819.                         case epOperationFloatEqual:
  820.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  821.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  822.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  823.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  824.                                 ,PRERR(ForceAbort,
  825.                                 "EvaluatePcode [epOperationFloatEqual]: bad stack element type"));
  826.                             Stack[StackPtr - 1].Data.Integer =
  827.                                 Stack[StackPtr - 1].Data.Float == Stack[StackPtr].Data.Float;
  828.                             StackPtr -= 1;
  829.                             break;
  830.                         case epOperationFloatNotEqual:
  831.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  832.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  833.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  834.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  835.                                 ,PRERR(ForceAbort,
  836.                                 "EvaluatePcode [epOperationFloatNotEqual]: bad stack element type"));
  837.                             Stack[StackPtr - 1].Data.Integer =
  838.                                 Stack[StackPtr - 1].Data.Float != Stack[StackPtr].Data.Float;
  839.                             StackPtr -= 1;
  840.                             break;
  841.                         case epOperationFloatAbs:
  842.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  843.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  844.                                 "EvaluatePcode [epOperationFloatAbs]: bad stack element type"));
  845.                             if (Stack[StackPtr].Data.Float < 0)
  846.                                 {
  847.                                     Stack[StackPtr].Data.Float = - Stack[StackPtr].Data.Float;
  848.                                 }
  849.                             break;
  850.                         case epOperationFloatToBoolean:
  851.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  852.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  853.                                 "EvaluatePcode [epOperationFloatToBoolean]: bad stack element type"));
  854.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Float != 0;
  855.                             break;
  856.                         case epOperationFloatToInteger:
  857.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  858.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  859.                                 "EvaluatePcode [epOperationFloatToInteger]: bad stack element type"));
  860.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Float;
  861.                             break;
  862.                         case epOperationFloatToDouble:
  863.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  864.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  865.                                 "EvaluatePcode [epOperationFloatToDouble]: bad stack element type"));
  866.                             Stack[StackPtr].Data.Double = Stack[StackPtr].Data.Float;
  867.                             break;
  868.                         case epOperationFloatToFixed:
  869.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  870.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  871.                                 "EvaluatePcode [epOperationFloatToFixed]: bad stack element type"));
  872.                             Stack[StackPtr].Data.Integer = double2largefixed(Stack[StackPtr].Data.Float);
  873.                             break;
  874.                         case epOperationDoubleAdd:
  875.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  876.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  877.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  878.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  879.                                 ,PRERR(ForceAbort,
  880.                                 "EvaluatePcode [epOperationDoubleAdd]: bad stack element type"));
  881.                             Stack[StackPtr - 1].Data.Double =
  882.                                 Stack[StackPtr - 1].Data.Double + Stack[StackPtr].Data.Double;
  883.                             StackPtr -= 1;
  884.                             break;
  885.                         case epOperationDoubleSubtract:
  886.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  887.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  888.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  889.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  890.                                 ,PRERR(ForceAbort,
  891.                                 "EvaluatePcode [epOperationDoubleSubtract]: bad stack element type"));
  892.                             Stack[StackPtr - 1].Data.Double =
  893.                                 Stack[StackPtr - 1].Data.Double - Stack[StackPtr].Data.Double;
  894.                             StackPtr -= 1;
  895.                             break;
  896.                         case epOperationDoubleNegation:
  897.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  898.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  899.                                 ,PRERR(ForceAbort,
  900.                                 "EvaluatePcode [epOperationDoubleNegation]: bad stack element type"));
  901.                             Stack[StackPtr].Data.Double = - Stack[StackPtr].Data.Double;
  902.                             break;
  903.                         case epOperationDoubleMultiply:
  904.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  905.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  906.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  907.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  908.                                 ,PRERR(ForceAbort,
  909.                                 "EvaluatePcode [epOperationDoubleMultiply]: bad stack element type"));
  910.                             Stack[StackPtr - 1].Data.Double =
  911.                                 Stack[StackPtr - 1].Data.Double * Stack[StackPtr].Data.Double;
  912.                             StackPtr -= 1;
  913.                             break;
  914.                         case epOperationDoubleDivide:
  915.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  916.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  917.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  918.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  919.                                 ,PRERR(ForceAbort,
  920.                                 "EvaluatePcode [epOperationDoubleDivide]: bad stack element type"));
  921.                             Stack[StackPtr - 1].Data.Double =
  922.                                 Stack[StackPtr - 1].Data.Double / Stack[StackPtr].Data.Double;
  923.                             StackPtr -= 1;
  924.                             break;
  925.                         case epOperationDoubleShiftLeft:
  926.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  927.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  928.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  929.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  930.                                 ,PRERR(ForceAbort,
  931.                                 "EvaluatePcode [epOperationDoubleShiftLeft]: bad stack element type"));
  932.                             Stack[StackPtr - 1].Data.Double =
  933.                                 Stack[StackPtr - 1].Data.Double * DPOWER(2,Stack[StackPtr].Data.Integer);
  934.                             StackPtr -= 1;
  935.                             break;
  936.                         case epOperationDoubleShiftRight:
  937.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  938.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  939.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  940.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  941.                                 ,PRERR(ForceAbort,
  942.                                 "EvaluatePcode [epOperationDoubleShiftLeft]: bad stack element type"));
  943.                             Stack[StackPtr - 1].Data.Double =
  944.                                 Stack[StackPtr - 1].Data.Double * DPOWER(2,-Stack[StackPtr].Data.Integer);
  945.                             StackPtr -= 1;
  946.                             break;
  947.                         case epOperationDoubleGreaterThan:
  948.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  949.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  950.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  951.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  952.                                 ,PRERR(ForceAbort,
  953.                                 "EvaluatePcode [epOperationDoubleGreaterThan]: bad stack element type"));
  954.                             Stack[StackPtr - 1].Data.Integer =
  955.                                 Stack[StackPtr - 1].Data.Double > Stack[StackPtr].Data.Double;
  956.                             StackPtr -= 1;
  957.                             break;
  958.                         case epOperationDoubleLessThan:
  959.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  960.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  961.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  962.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  963.                                 ,PRERR(ForceAbort,
  964.                                 "EvaluatePcode [epOperationDoubleLessThan]: bad stack element type"));
  965.                             Stack[StackPtr - 1].Data.Integer =
  966.                                 Stack[StackPtr - 1].Data.Double < Stack[StackPtr].Data.Double;
  967.                             StackPtr -= 1;
  968.                             break;
  969.                         case epOperationDoubleGreaterThanOrEqual:
  970.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  971.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  972.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  973.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  974.                                 ,PRERR(ForceAbort,
  975.                                 "EvaluatePcode [epOperationDoubleGreaterThanOrEqual]: bad stack element type"));
  976.                             Stack[StackPtr - 1].Data.Integer =
  977.                                 Stack[StackPtr - 1].Data.Double >= Stack[StackPtr].Data.Double;
  978.                             StackPtr -= 1;
  979.                             break;
  980.                         case epOperationDoubleLessThanOrEqual:
  981.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  982.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  983.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  984.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  985.                                 ,PRERR(ForceAbort,
  986.                                 "EvaluatePcode [epOperationDoubleLessThanOrEqual]: bad stack element type"));
  987.                             Stack[StackPtr - 1].Data.Integer =
  988.                                 Stack[StackPtr - 1].Data.Double <= Stack[StackPtr].Data.Double;
  989.                             StackPtr -= 1;
  990.                             break;
  991.                         case epOperationDoubleEqual:
  992.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  993.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  994.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  995.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  996.                                 ,PRERR(ForceAbort,
  997.                                 "EvaluatePcode [epOperationDoubleEqual]: bad stack element type"));
  998.                             Stack[StackPtr - 1].Data.Integer =
  999.                                 Stack[StackPtr - 1].Data.Double == Stack[StackPtr].Data.Double;
  1000.                             StackPtr -= 1;
  1001.                             break;
  1002.                         case epOperationDoubleNotEqual:
  1003.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1004.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1005.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1006.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1007.                                 ,PRERR(ForceAbort,
  1008.                                 "EvaluatePcode [epOperationDoubleNotEqual]: bad stack element type"));
  1009.                             Stack[StackPtr - 1].Data.Integer =
  1010.                                 Stack[StackPtr - 1].Data.Double != Stack[StackPtr].Data.Double;
  1011.                             StackPtr -= 1;
  1012.                             break;
  1013.                         case epOperationDoubleAbs:
  1014.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1015.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1016.                                 "EvaluatePcode [epOperationDoubleAbs]: bad stack element type"));
  1017.                             if (Stack[StackPtr].Data.Double < 0)
  1018.                                 {
  1019.                                     Stack[StackPtr].Data.Double = - Stack[StackPtr].Data.Double;
  1020.                                 }
  1021.                             break;
  1022.                         case epOperationDoubleToBoolean:
  1023.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1024.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1025.                                 "EvaluatePcode [epOperationDoubleToBoolean]: bad stack element type"));
  1026.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Double != 0;
  1027.                             break;
  1028.                         case epOperationDoubleToInteger:
  1029.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1030.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1031.                                 "EvaluatePcode [epOperationDoubleToInteger]: bad stack element type"));
  1032.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Double;
  1033.                             break;
  1034.                         case epOperationDoubleToFloat:
  1035.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1036.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1037.                                 "EvaluatePcode [epOperationDoubleToFloat]: bad stack element type"));
  1038.                             Stack[StackPtr].Data.Float = Stack[StackPtr].Data.Double;
  1039.                             break;
  1040.                         case epOperationDoubleToFixed:
  1041.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1042.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1043.                                 "EvaluatePcode [epOperationDoubleToFixed]: bad stack element type"));
  1044.                             Stack[StackPtr].Data.Integer = double2largefixed(Stack[StackPtr].Data.Double);
  1045.                             break;
  1046.                         case epOperationDoubleSin:
  1047.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1048.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1049.                                 "EvaluatePcode [epOperationDoubleSin]: bad stack element type"));
  1050.                             Stack[StackPtr].Data.Double = DSIN(Stack[StackPtr].Data.Double);
  1051.                             break;
  1052.                         case epOperationDoubleCos:
  1053.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1054.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1055.                                 "EvaluatePcode [epOperationDoubleCos]: bad stack element type"));
  1056.                             Stack[StackPtr].Data.Double = DCOS(Stack[StackPtr].Data.Double);
  1057.                             break;
  1058.                         case epOperationDoubleTan:
  1059.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1060.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1061.                                 "EvaluatePcode [epOperationDoubleTan]: bad stack element type"));
  1062.                             Stack[StackPtr].Data.Double = DTAN(Stack[StackPtr].Data.Double);
  1063.                             break;
  1064.                         case epOperationDoubleAsin:
  1065.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1066.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1067.                                 "EvaluatePcode [epOperationDoubleAsin]: bad stack element type"));
  1068.                             Stack[StackPtr].Data.Double = DASIN(Stack[StackPtr].Data.Double);
  1069.                             break;
  1070.                         case epOperationDoubleAcos:
  1071.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1072.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1073.                                 "EvaluatePcode [epOperationDoubleAcos]: bad stack element type"));
  1074.                             Stack[StackPtr].Data.Double = DACOS(Stack[StackPtr].Data.Double);
  1075.                             break;
  1076.                         case epOperationDoubleAtan:
  1077.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1078.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1079.                                 "EvaluatePcode [epOperationDoubleAtan]: bad stack element type"));
  1080.                             Stack[StackPtr].Data.Double = DATAN(Stack[StackPtr].Data.Double);
  1081.                             break;
  1082.                         case epOperationDoubleLn:
  1083.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1084.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1085.                                 "EvaluatePcode [epOperationDoubleLn]: bad stack element type"));
  1086.                             Stack[StackPtr].Data.Double = DLN(Stack[StackPtr].Data.Double);
  1087.                             break;
  1088.                         case epOperationDoubleExp:
  1089.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1090.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1091.                                 "EvaluatePcode [epOperationDoubleExp]: bad stack element type"));
  1092.                             Stack[StackPtr].Data.Double = DEXP(Stack[StackPtr].Data.Double);
  1093.                             break;
  1094.                         case epOperationDoubleSqrt:
  1095.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1096.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1097.                                 "EvaluatePcode [epOperationDoubleSqrt]: bad stack element type"));
  1098.                             Stack[StackPtr].Data.Double = DSQRT(Stack[StackPtr].Data.Double);
  1099.                             break;
  1100.                         case epOperationDoubleSqr:
  1101.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1102.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1103.                                 "EvaluatePcode [epOperationDoubleSqr]: bad stack element type"));
  1104.                             Stack[StackPtr].Data.Double = Stack[StackPtr].Data.Double
  1105.                                 * Stack[StackPtr].Data.Double;
  1106.                             break;
  1107.                         case epOperationDoublePower:
  1108.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1109.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1110.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1111.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1112.                                 ,PRERR(ForceAbort,
  1113.                                 "EvaluatePcode [epOperationDoublePower]: bad stack element type"));
  1114.                             Stack[StackPtr - 1].Data.Double =
  1115.                                 DPOWER(Stack[StackPtr - 1].Data.Double,Stack[StackPtr].Data.Double);
  1116.                             StackPtr -= 1;
  1117.                             break;
  1118.                         case epOperationFixedMultiply:
  1119.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1120.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1121.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1122.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1123.                                 ,PRERR(ForceAbort,
  1124.                                 "EvaluatePcode [epOperationFixedMultiply]: bad stack element type"));
  1125.                             Stack[StackPtr - 1].Data.Integer = largefixedmult(
  1126.                                 Stack[StackPtr - 1].Data.Integer,Stack[StackPtr].Data.Integer);
  1127.                             StackPtr -= 1;
  1128.                             break;
  1129.                         case epOperationFixedDivide:
  1130.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1131.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1132.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1133.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1134.                                 ,PRERR(ForceAbort,
  1135.                                 "EvaluatePcode [epOperationFixedDivide]: bad stack element type"));
  1136.                             Stack[StackPtr - 1].Data.Integer = double2largefixed(
  1137.                                 largefixed2double(Stack[StackPtr - 1].Data.Integer)
  1138.                                 / largefixed2double(Stack[StackPtr].Data.Integer));
  1139.                             StackPtr -= 1;
  1140.                             break;
  1141.                         case epOperationFixedToInteger:
  1142.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1143.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1144.                                 "EvaluatePcode [epOperationFixedToInteger]: bad stack element type"));
  1145.                             Stack[StackPtr].Data.Integer = largefixed2int(Stack[StackPtr].Data.Integer);
  1146.                             break;
  1147.                         case epOperationFixedToFloat:
  1148.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1149.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1150.                                 "EvaluatePcode [epOperationFixedToFloat]: bad stack element type"));
  1151.                             Stack[StackPtr].Data.Float = largefixed2double(Stack[StackPtr].Data.Integer);
  1152.                             break;
  1153.                         case epOperationFixedToDouble:
  1154.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1155.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1156.                                 "EvaluatePcode [epOperationFixedToDouble]: bad stack element type"));
  1157.                             Stack[StackPtr].Data.Double = largefixed2double(Stack[StackPtr].Data.Integer);
  1158.                             break;
  1159.  
  1160.                         /* other conversion operations */
  1161.                         case epOperationBooleanToIntegerBuried:  /* <opcode> <stackindex> */
  1162.                             /*    -1            0    */
  1163.                             /* <opcode> <branchoffset> */
  1164.                             PRNGCHK(CurrentProcedure,
  1165.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1166.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1167.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1168.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1169.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1170.                                 "EvaluatePcode [epOperationBooleanToIntegerBuried]:  not a scalar"));
  1171.                             ProgramCounter += 1;
  1172.                             break;
  1173.                         case epOperationIntegerToFloatBuried:
  1174.                         case epOperationBooleanToFloatBuried:
  1175.                             /*    -1            0    */
  1176.                             /* <opcode> <branchoffset> */
  1177.                             PRNGCHK(CurrentProcedure,
  1178.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1179.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1180.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1181.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1182.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1183.                                 "EvaluatePcode [epOperationIntegerToFloatBuried]:  not a scalar"));
  1184.                             Stack[Index].Data.Float = Stack[Index].Data.Integer;
  1185.                             ProgramCounter += 1;
  1186.                             break;
  1187.                         case epOperationIntegerToDoubleBuried:
  1188.                         case epOperationBooleanToDoubleBuried:
  1189.                             /*    -1            0    */
  1190.                             /* <opcode> <branchoffset> */
  1191.                             PRNGCHK(CurrentProcedure,
  1192.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1193.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1194.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1195.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1196.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1197.                                 "EvaluatePcode [epOperationIntegerToDoubleBuried]:  not a scalar"));
  1198.                             Stack[Index].Data.Double = Stack[Index].Data.Integer;
  1199.                             ProgramCounter += 1;
  1200.                             break;
  1201.                         case epOperationIntegerToFixedBuried:
  1202.                         case epOperationBooleanToFixedBuried:
  1203.                             /*    -1            0    */
  1204.                             /* <opcode> <branchoffset> */
  1205.                             PRNGCHK(CurrentProcedure,
  1206.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1207.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1208.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1209.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1210.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1211.                                 "EvaluatePcode [epOperationIntegerToFixedBuried]:  not a scalar"));
  1212.                             Stack[Index].Data.Integer = int2largefixed(Stack[Index].Data.Integer);
  1213.                             ProgramCounter += 1;
  1214.                             break;
  1215.                         case epOperationFixedToBooleanBuried:
  1216.                         case epOperationIntegerToBooleanBuried:
  1217.                             /*    -1            0    */
  1218.                             /* <opcode> <branchoffset> */
  1219.                             PRNGCHK(CurrentProcedure,
  1220.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1221.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1222.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1223.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1224.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1225.                                 "EvaluatePcode [epOperationIntegerToBooleanBuried]:  not a scalar"));
  1226.                             Stack[Index].Data.Integer = Stack[Index].Data.Integer != 0;
  1227.                             ProgramCounter += 1;
  1228.                             break;
  1229.                         case epOperationFloatToBooleanBuried:
  1230.                             /*    -1            0    */
  1231.                             /* <opcode> <branchoffset> */
  1232.                             PRNGCHK(CurrentProcedure,
  1233.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1234.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1235.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1236.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1237.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1238.                                 "EvaluatePcode [epOperationFloatToBooleanBuried]:  not a scalar"));
  1239.                             Stack[Index].Data.Integer = Stack[Index].Data.Float != 0;
  1240.                             ProgramCounter += 1;
  1241.                             break;
  1242.                         case epOperationFloatToIntegerBuried:
  1243.                             /*    -1            0    */
  1244.                             /* <opcode> <branchoffset> */
  1245.                             PRNGCHK(CurrentProcedure,
  1246.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1247.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1248.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1249.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1250.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1251.                                 "EvaluatePcode [epOperationFloatToIntegerBuried]:  not a scalar"));
  1252.                             Stack[Index].Data.Integer = Stack[Index].Data.Float;
  1253.                             ProgramCounter += 1;
  1254.                             break;
  1255.                         case epOperationFloatToDoubleBuried:
  1256.                             /*    -1            0    */
  1257.                             /* <opcode> <branchoffset> */
  1258.                             PRNGCHK(CurrentProcedure,
  1259.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1260.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1261.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1262.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1263.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1264.                                 "EvaluatePcode [epOperationFloatToDoubleBuried]:  not a scalar"));
  1265.                             Stack[Index].Data.Double = Stack[Index].Data.Float;
  1266.                             ProgramCounter += 1;
  1267.                             break;
  1268.                         case epOperationFloatToFixedBuried:
  1269.                             /*    -1            0    */
  1270.                             /* <opcode> <branchoffset> */
  1271.                             PRNGCHK(CurrentProcedure,
  1272.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1273.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1274.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1275.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1276.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1277.                                 "EvaluatePcode [epOperationFloatToFixedBuried]:  not a scalar"));
  1278.                             Stack[Index].Data.Integer = double2largefixed(Stack[Index].Data.Float);
  1279.                             ProgramCounter += 1;
  1280.                             break;
  1281.                         case epOperationDoubleToBooleanBuried:
  1282.                             /*    -1            0    */
  1283.                             /* <opcode> <branchoffset> */
  1284.                             PRNGCHK(CurrentProcedure,
  1285.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1286.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1287.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1288.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1289.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1290.                                 "EvaluatePcode [epOperationDoubleToBooleanBuried]:  not a scalar"));
  1291.                             Stack[Index].Data.Integer = Stack[Index].Data.Double != 0;
  1292.                             ProgramCounter += 1;
  1293.                             break;
  1294.                         case epOperationDoubleToIntegerBuried:
  1295.                             /*    -1            0    */
  1296.                             /* <opcode> <branchoffset> */
  1297.                             PRNGCHK(CurrentProcedure,
  1298.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1299.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1300.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1301.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1302.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1303.                                 "EvaluatePcode [epOperationDoubleToIntegerBuried]:  not a scalar"));
  1304.                             Stack[Index].Data.Integer = Stack[Index].Data.Double;
  1305.                             ProgramCounter += 1;
  1306.                             break;
  1307.                         case epOperationDoubleToFloatBuried:
  1308.                             /*    -1            0    */
  1309.                             /* <opcode> <branchoffset> */
  1310.                             PRNGCHK(CurrentProcedure,
  1311.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1312.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1313.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1314.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1315.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1316.                                 "EvaluatePcode [epOperationDoubleToFloatBuried]:  not a scalar"));
  1317.                             Stack[Index].Data.Float = Stack[Index].Data.Double;
  1318.                             ProgramCounter += 1;
  1319.                             break;
  1320.                         case epOperationDoubleToFixedBuried:
  1321.                             /*    -1            0    */
  1322.                             /* <opcode> <branchoffset> */
  1323.                             PRNGCHK(CurrentProcedure,
  1324.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1325.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1326.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1327.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1328.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1329.                                 "EvaluatePcode [epOperationDoubleToFixedBuried]:  not a scalar"));
  1330.                             Stack[Index].Data.Integer = double2largefixed(Stack[Index].Data.Double);
  1331.                             ProgramCounter += 1;
  1332.                             break;
  1333.                         case epOperationFixedToIntegerBuried:
  1334.                             /*    -1            0    */
  1335.                             /* <opcode> <branchoffset> */
  1336.                             PRNGCHK(CurrentProcedure,
  1337.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1338.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1339.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1340.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1341.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1342.                                 "EvaluatePcode [epOperationFixedToIntegerBuried]:  not a scalar"));
  1343.                             Stack[Index].Data.Integer = largefixed2int(Stack[Index].Data.Integer);
  1344.                             ProgramCounter += 1;
  1345.                             break;
  1346.                         case epOperationFixedToFloatBuried:
  1347.                             /*    -1            0    */
  1348.                             /* <opcode> <branchoffset> */
  1349.                             PRNGCHK(CurrentProcedure,
  1350.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1351.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1352.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1353.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1354.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1355.                                 "EvaluatePcode [epOperationFixedToFloatBuried]:  not a scalar"));
  1356.                             Stack[Index].Data.Float = largefixed2double(Stack[Index].Data.Integer);
  1357.                             ProgramCounter += 1;
  1358.                             break;
  1359.                         case epOperationFixedToDoubleBuried:
  1360.                             /*    -1            0    */
  1361.                             /* <opcode> <branchoffset> */
  1362.                             PRNGCHK(CurrentProcedure,
  1363.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1364.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1365.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1366.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1367.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1368.                                 "EvaluatePcode [epOperationFixedToDoubleBuried]:  not a scalar"));
  1369.                             Stack[Index].Data.Double = largefixed2double(Stack[Index].Data.Integer);
  1370.                             ProgramCounter += 1;
  1371.                             break;
  1372.  
  1373.                         /* array sizing stuff. */
  1374.                         case epGetBooleanArraySize:
  1375.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1376.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1377.                                 "EvaluatePcode [epGetBooleanArraySize]: bad stack element type"));
  1378.                             if (Stack[StackPtr].Data.Array == NIL)
  1379.                                 {
  1380.                                     ErrorCode = eEvalArrayDoesntExist;
  1381.                                     goto ExceptionPoint;
  1382.                                 }
  1383.                             Index = PtrSize((char*)Stack[StackPtr].Data.Array);
  1384.                             DisposeIfNotOnStack(Stack,StackPtr);
  1385.                             Stack[StackPtr].ElementType = esScalar;
  1386.                             Stack[StackPtr].Data.Integer = Index;
  1387.                             break;
  1388.                         case epGetIntegerArraySize:
  1389.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1390.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1391.                                 "EvaluatePcode [epGetIntegerArraySize]: bad stack element type"));
  1392.                             if (Stack[StackPtr].Data.Array == NIL)
  1393.                                 {
  1394.                                     ErrorCode = eEvalArrayDoesntExist;
  1395.                                     goto ExceptionPoint;
  1396.                                 }
  1397.                             Index = PtrSize((char*)Stack[StackPtr].Data.Array) / sizeof(long);
  1398.                             DisposeIfNotOnStack(Stack,StackPtr);
  1399.                             Stack[StackPtr].ElementType = esScalar;
  1400.                             Stack[StackPtr].Data.Integer = Index;
  1401.                             break;
  1402.                         case epGetFloatArraySize:
  1403.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1404.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1405.                                 "EvaluatePcode [epGetFloatArraySize]: bad stack element type"));
  1406.                             if (Stack[StackPtr].Data.Array == NIL)
  1407.                                 {
  1408.                                     ErrorCode = eEvalArrayDoesntExist;
  1409.                                     goto ExceptionPoint;
  1410.                                 }
  1411.                             Index = PtrSize((char*)Stack[StackPtr].Data.Array) / sizeof(float);
  1412.                             DisposeIfNotOnStack(Stack,StackPtr);
  1413.                             Stack[StackPtr].ElementType = esScalar;
  1414.                             Stack[StackPtr].Data.Integer = Index;
  1415.                             break;
  1416.                         case epGetDoubleArraySize:
  1417.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1418.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1419.                                 "EvaluatePcode [epGetDoubleArraySize]: bad stack element type"));
  1420.                             if (Stack[StackPtr].Data.Array == NIL)
  1421.                                 {
  1422.                                     ErrorCode = eEvalArrayDoesntExist;
  1423.                                     goto ExceptionPoint;
  1424.                                 }
  1425.                             Index = PtrSize((char*)Stack[StackPtr].Data.Array) / sizeof(double);
  1426.                             DisposeIfNotOnStack(Stack,StackPtr);
  1427.                             Stack[StackPtr].ElementType = esScalar;
  1428.                             Stack[StackPtr].Data.Integer = Index;
  1429.                             break;
  1430.                         case epGetFixedArraySize:
  1431.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1432.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1433.                                 "EvaluatePcode [epGetFixedArraySize]: bad stack element type"));
  1434.                             if (Stack[StackPtr].Data.Array == NIL)
  1435.                                 {
  1436.                                     ErrorCode = eEvalArrayDoesntExist;
  1437.                                     goto ExceptionPoint;
  1438.                                 }
  1439.                             Index = PtrSize((char*)Stack[StackPtr].Data.Array)
  1440.                                 / sizeof(largefixedsigned);
  1441.                             DisposeIfNotOnStack(Stack,StackPtr);
  1442.                             Stack[StackPtr].ElementType = esScalar;
  1443.                             Stack[StackPtr].Data.Integer = Index;
  1444.                             break;
  1445.  
  1446.                         case epResizeBooleanArray2:
  1447.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1448.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1449.                                 "EvaluatePcode [epResizeBooleanArray]: bad stack element type"));
  1450.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1451.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1452.                                 "EvaluatePcode [epResizeBooleanArray2]:  array slot of wrong type"));
  1453.                             if (Stack[StackPtr].Data.Integer < 0)
  1454.                                 {
  1455.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1456.                                     goto ExceptionPoint;
  1457.                                 }
  1458.                             if (Stack[StackPtr - 1].Data.Array != NIL)
  1459.                                 {
  1460.                                     void*                    OldReference;
  1461.                                     void*                    NewReference;
  1462.                                     long                    SizeDifference;
  1463.  
  1464.                                     OldReference = Stack[StackPtr - 1].Data.Array;
  1465.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1466.                                         - (PtrSize((char*)OldReference) / sizeof(char));
  1467.                                     NewReference = ResizePtr((char*)OldReference,
  1468.                                         Stack[StackPtr].Data.Integer);
  1469.                                     if (NewReference == NIL)
  1470.                                         {
  1471.                                             ErrorCode = eEvalOutOfMemory;
  1472.                                             goto ExceptionPoint;
  1473.                                         }
  1474.                                     /* now patch up the references */
  1475.                                     UpdateStackArrayRefs(Stack,StackPtr,OldReference,NewReference);
  1476.                                     /* if we added to the array, then we have to zero those elements */
  1477.                                     if (SizeDifference > 0)
  1478.                                         {
  1479.                                             long                    Limit;
  1480.  
  1481.                                             Limit = Stack[StackPtr].Data.Integer;
  1482.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1483.                                                 {
  1484.                                                     PRNGCHK(NewReference,&(((char*)NewReference)[Index]),
  1485.                                                         sizeof(char));
  1486.                                                     ((char*)NewReference)[Index] = 0;
  1487.                                                 }
  1488.                                         }
  1489.                                 }
  1490.                              else
  1491.                                 {
  1492.                                     ErrorCode = eEvalArrayDoesntExist;
  1493.                                     goto ExceptionPoint;
  1494.                                 }
  1495.                             StackPtr -= 1;
  1496.                             break;
  1497.                         case epResizeIntegerArray2:
  1498.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1499.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1500.                                 "EvaluatePcode [epResizeIntegerArray]: bad stack element type"));
  1501.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1502.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1503.                                 "EvaluatePcode [epResizeIntegerArray]:  array slot of wrong type"));
  1504.                             if (Stack[StackPtr].Data.Integer < 0)
  1505.                                 {
  1506.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1507.                                     goto ExceptionPoint;
  1508.                                 }
  1509.                             if (Stack[StackPtr - 1].Data.Array != NIL)
  1510.                                 {
  1511.                                     void*                    OldReference;
  1512.                                     void*                    NewReference;
  1513.                                     long                    SizeDifference;
  1514.  
  1515.                                     OldReference = Stack[StackPtr - 1].Data.Array;
  1516.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1517.                                         - (PtrSize((char*)OldReference) / sizeof(long));
  1518.                                     NewReference = ResizePtr((char*)OldReference,
  1519.                                         Stack[StackPtr].Data.Integer * sizeof(long));
  1520.                                     if (NewReference == NIL)
  1521.                                         {
  1522.                                             ErrorCode = eEvalOutOfMemory;
  1523.                                             goto ExceptionPoint;
  1524.                                         }
  1525.                                     /* now patch up the references */
  1526.                                     UpdateStackArrayRefs(Stack,StackPtr,OldReference,NewReference);
  1527.                                     /* if we added to the array, then we have to zero those elements */
  1528.                                     if (SizeDifference > 0)
  1529.                                         {
  1530.                                             long                    Limit;
  1531.  
  1532.                                             Limit = Stack[StackPtr].Data.Integer;
  1533.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1534.                                                 {
  1535.                                                     PRNGCHK(NewReference,&(((long*)NewReference)[Index]),
  1536.                                                         sizeof(long));
  1537.                                                     ((long*)NewReference)[Index] = 0;
  1538.                                                 }
  1539.                                         }
  1540.                                 }
  1541.                              else
  1542.                                 {
  1543.                                     ErrorCode = eEvalArrayDoesntExist;
  1544.                                     goto ExceptionPoint;
  1545.                                 }
  1546.                             StackPtr -= 1;
  1547.                             break;
  1548.                         case epResizeFloatArray2:
  1549.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1550.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1551.                                 "EvaluatePcode [epResizeFloatArray]: bad stack element type"));
  1552.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1553.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1554.                                 "EvaluatePcode [epResizeFloatArray]:  array slot of wrong type"));
  1555.                             if (Stack[StackPtr].Data.Integer < 0)
  1556.                                 {
  1557.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1558.                                     goto ExceptionPoint;
  1559.                                 }
  1560.                             if (Stack[StackPtr - 1].Data.Array != NIL)
  1561.                                 {
  1562.                                     void*                    OldReference;
  1563.                                     void*                    NewReference;
  1564.                                     long                    SizeDifference;
  1565.  
  1566.                                     OldReference = Stack[StackPtr - 1].Data.Array;
  1567.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1568.                                         - (PtrSize((char*)OldReference) / sizeof(float));
  1569.                                     NewReference = ResizePtr((char*)OldReference,
  1570.                                         Stack[StackPtr].Data.Integer * sizeof(float));
  1571.                                     if (NewReference == NIL)
  1572.                                         {
  1573.                                             ErrorCode = eEvalOutOfMemory;
  1574.                                             goto ExceptionPoint;
  1575.                                         }
  1576.                                     /* now patch up the references */
  1577.                                     UpdateStackArrayRefs(Stack,StackPtr,OldReference,NewReference);
  1578.                                     /* if we added to the array, then we have to zero those elements */
  1579.                                     if (SizeDifference > 0)
  1580.                                         {
  1581.                                             long                    Limit;
  1582.  
  1583.                                             Limit = Stack[StackPtr].Data.Integer;
  1584.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1585.                                                 {
  1586.                                                     PRNGCHK(NewReference,&(((float*)NewReference)[Index]),
  1587.                                                         sizeof(float));
  1588.                                                     ((float*)NewReference)[Index] = 0;
  1589.                                                 }
  1590.                                         }
  1591.                                 }
  1592.                              else
  1593.                                 {
  1594.                                     ErrorCode = eEvalArrayDoesntExist;
  1595.                                     goto ExceptionPoint;
  1596.                                 }
  1597.                             StackPtr -= 1;
  1598.                             break;
  1599.                         case epResizeDoubleArray2:
  1600.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1601.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1602.                                 "EvaluatePcode [epResizeDoubleArray]: bad stack element type"));
  1603.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1604.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1605.                                 "EvaluatePcode [epResizeDoubleArray]:  array slot of wrong type"));
  1606.                             if (Stack[StackPtr].Data.Integer < 0)
  1607.                                 {
  1608.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1609.                                     goto ExceptionPoint;
  1610.                                 }
  1611.                             if (Stack[StackPtr - 1].Data.Array != NIL)
  1612.                                 {
  1613.                                     void*                    OldReference;
  1614.                                     void*                    NewReference;
  1615.                                     long                    SizeDifference;
  1616.  
  1617.                                     OldReference = Stack[StackPtr - 1].Data.Array;
  1618.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1619.                                         - (PtrSize((char*)OldReference) / sizeof(double));
  1620.                                     NewReference = ResizePtr((char*)OldReference,
  1621.                                         Stack[StackPtr].Data.Integer * sizeof(double));
  1622.                                     if (NewReference == NIL)
  1623.                                         {
  1624.                                             ErrorCode = eEvalOutOfMemory;
  1625.                                             goto ExceptionPoint;
  1626.                                         }
  1627.                                     /* now patch up the references */
  1628.                                     UpdateStackArrayRefs(Stack,StackPtr,OldReference,NewReference);
  1629.                                     /* if we added to the array, then we have to zero those elements */
  1630.                                     if (SizeDifference > 0)
  1631.                                         {
  1632.                                             long                    Limit;
  1633.  
  1634.                                             Limit = Stack[StackPtr].Data.Integer;
  1635.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1636.                                                 {
  1637.                                                     PRNGCHK(NewReference,&(((double*)NewReference)[Index]),
  1638.                                                         sizeof(double));
  1639.                                                     ((double*)NewReference)[Index] = 0;
  1640.                                                 }
  1641.                                         }
  1642.                                 }
  1643.                              else
  1644.                                 {
  1645.                                     ErrorCode = eEvalArrayDoesntExist;
  1646.                                     goto ExceptionPoint;
  1647.                                 }
  1648.                             StackPtr -= 1;
  1649.                             break;
  1650.                         case epResizeFixedArray2:
  1651.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1652.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1653.                                 "EvaluatePcode [epResizeFixedArray]: bad stack element type"));
  1654.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1655.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1656.                                 "EvaluatePcode [epResizeFixedArray]:  array slot of wrong type"));
  1657.                             if (Stack[StackPtr].Data.Integer < 0)
  1658.                                 {
  1659.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1660.                                     goto ExceptionPoint;
  1661.                                 }
  1662.                             if (Stack[StackPtr - 1].Data.Array != NIL)
  1663.                                 {
  1664.                                     void*                    OldReference;
  1665.                                     void*                    NewReference;
  1666.                                     long                    SizeDifference;
  1667.  
  1668.                                     OldReference = Stack[StackPtr - 1].Data.Array;
  1669.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1670.                                         - (PtrSize((char*)OldReference) / sizeof(largefixedsigned));
  1671.                                     NewReference = ResizePtr((char*)OldReference,
  1672.                                         Stack[StackPtr].Data.Integer * sizeof(largefixedsigned));
  1673.                                     if (NewReference == NIL)
  1674.                                         {
  1675.                                             ErrorCode = eEvalOutOfMemory;
  1676.                                             goto ExceptionPoint;
  1677.                                         }
  1678.                                     /* now patch up the references */
  1679.                                     UpdateStackArrayRefs(Stack,StackPtr,OldReference,NewReference);
  1680.                                     /* if we added to the array, then we have to zero those elements */
  1681.                                     if (SizeDifference > 0)
  1682.                                         {
  1683.                                             long                    Limit;
  1684.  
  1685.                                             Limit = Stack[StackPtr].Data.Integer;
  1686.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1687.                                                 {
  1688.                                                     PRNGCHK(NewReference,
  1689.                                                         &(((largefixedsigned*)NewReference)[Index]),
  1690.                                                         sizeof(largefixedsigned));
  1691.                                                     ((largefixedsigned*)NewReference)[Index] = 0;
  1692.                                                 }
  1693.                                         }
  1694.                                 }
  1695.                              else
  1696.                                 {
  1697.                                     ErrorCode = eEvalArrayDoesntExist;
  1698.                                     goto ExceptionPoint;
  1699.                                 }
  1700.                             StackPtr -= 1;
  1701.                             break;
  1702.  
  1703.                         case epStoreIntegerOnStack:
  1704.                             /*    -1         0    */
  1705.                             /* <opcode> <stackindex> */
  1706.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1707.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1708.                                 "EvaluatePcode [epStoreIntegerOnStack]: bad stack element type"));
  1709.                             PRNGCHK(CurrentProcedure,
  1710.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1711.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1712.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1713.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1714.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1715.                                 "EvaluatePcode [epStoreIntegerOnStack]:  array slot of wrong type"));
  1716.                             Stack[Index].Data.Integer = Stack[StackPtr].Data.Integer;
  1717.                             ProgramCounter += 1;
  1718.                             /* don't pop the value from the stack though */
  1719.                             break;
  1720.                         case epStoreFloatOnStack:
  1721.                             /*    -1         0    */
  1722.                             /* <opcode> <stackindex> */
  1723.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1724.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1725.                                 "EvaluatePcode [epStoreFloatOnStack]: bad stack element type"));
  1726.                             PRNGCHK(CurrentProcedure,
  1727.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1728.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1729.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1730.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1731.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1732.                                 "EvaluatePcode [epStoreFloatOnStack]:  array slot of wrong type"));
  1733.                             Stack[Index].Data.Float = Stack[StackPtr].Data.Float;
  1734.                             ProgramCounter += 1;
  1735.                             /* don't pop the value from the stack though */
  1736.                             break;
  1737.                         case epStoreDoubleOnStack:
  1738.                             /*    -1         0    */
  1739.                             /* <opcode> <stackindex> */
  1740.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1741.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1742.                                 "EvaluatePcode [epStoreDoubleOnStack]: bad stack element type"));
  1743.                             PRNGCHK(CurrentProcedure,
  1744.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1745.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1746.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1747.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1748.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1749.                                 "EvaluatePcode [epStoreDoubleOnStack]:  array slot of wrong type"));
  1750.                             Stack[Index].Data.Double = Stack[StackPtr].Data.Double;
  1751.                             ProgramCounter += 1;
  1752.                             /* don't pop the value from the stack though */
  1753.                             break;
  1754.                         case epStoreArrayOnStack:
  1755.                             /*    -1         0    */
  1756.                             /* <opcode> <stackindex> */
  1757.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1758.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1759.                                 "EvaluatePcode [epStoreArrayOnStack]: bad stack element type"));
  1760.                             /* this one has to make sure it deallocates an array that it overwrites. */
  1761.                             PRNGCHK(CurrentProcedure,
  1762.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1763.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1764.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1765.                             PRNGCHK(Stack,&(Stack[StackPtr + Index]),sizeof(Stack[StackPtr + Index]));
  1766.                             ERROR((Stack[Index].ElementType != esScalar)
  1767.                                 && (Stack[Index].ElementType != esArray),
  1768.                                 PRERR(ForceAbort,
  1769.                                 "EvaluatePcode [epStoreArrayOnStack]:  array slot of wrong type"));
  1770.                             if ((Stack[Index].ElementType == esArray)
  1771.                                 && (Stack[Index].Data.Array != NIL))
  1772.                                 {
  1773.                                     DisposeIfOnStackOnlyOnce(Stack,StackPtr,Index);
  1774.                                 }
  1775.                             Stack[Index].Data.Array = Stack[StackPtr].Data.Array;
  1776.                             Stack[Index].ElementType = esArray;
  1777.                             ProgramCounter += 1;
  1778.                             /* don't pop the value from the stack though */
  1779.                             break;
  1780.                         case epLoadIntegerFromStack:
  1781.                             /*    -1         0    */
  1782.                             /* <opcode> <stackindex> */
  1783.                             PRNGCHK(CurrentProcedure,
  1784.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1785.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1786.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1787.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1788.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1789.                                 "EvaluatePcode [epLoadIntegerFromStack]:  array slot of wrong type"));
  1790.                             StackPtr += 1;
  1791.                             if (StackPtr >= StackSize)
  1792.                                 {
  1793.                                     StackElement*            NewStack;
  1794.  
  1795.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1796.                                         * sizeof(StackElement));
  1797.                                     if (NewStack == NIL)
  1798.                                         {
  1799.                                             StackPtr -= 1;
  1800.                                             ErrorCode = eEvalOutOfMemory;
  1801.                                             goto ExceptionPoint;
  1802.                                         }
  1803.                                     Stack = NewStack;
  1804.                                     StackSize += 8;
  1805.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1806.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadIntegerFromStack]: stack size inconsistency"));
  1807.                                 }
  1808.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1809.                             Stack[StackPtr].Data.Integer = Stack[Index].Data.Integer;
  1810.                             Stack[StackPtr].ElementType = esScalar;
  1811.                             ProgramCounter += 1;
  1812.                             break;
  1813.                         case epLoadFloatFromStack:
  1814.                             /*    -1         0    */
  1815.                             /* <opcode> <stackindex> */
  1816.                             PRNGCHK(CurrentProcedure,
  1817.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1818.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1819.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1820.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1821.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1822.                                 "EvaluatePcode [epLoadFloatFromStack]:  array slot of wrong type"));
  1823.                             StackPtr += 1;
  1824.                             if (StackPtr >= StackSize)
  1825.                                 {
  1826.                                     StackElement*            NewStack;
  1827.  
  1828.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1829.                                         * sizeof(StackElement));
  1830.                                     if (NewStack == NIL)
  1831.                                         {
  1832.                                             StackPtr -= 1;
  1833.                                             ErrorCode = eEvalOutOfMemory;
  1834.                                             goto ExceptionPoint;
  1835.                                         }
  1836.                                     Stack = NewStack;
  1837.                                     StackSize += 8;
  1838.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1839.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadFloatFromStack]: stack size inconsistency"));
  1840.                                 }
  1841.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1842.                             Stack[StackPtr].Data.Float = Stack[Index].Data.Float;
  1843.                             Stack[StackPtr].ElementType = esScalar;
  1844.                             ProgramCounter += 1;
  1845.                             break;
  1846.                         case epLoadDoubleFromStack:
  1847.                             /*    -1         0    */
  1848.                             /* <opcode> <stackindex> */
  1849.                             PRNGCHK(CurrentProcedure,
  1850.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1851.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1852.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1853.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1854.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1855.                                 "EvaluatePcode [epLoadDoubleFromStack]:  array slot of wrong type"));
  1856.                             StackPtr += 1;
  1857.                             if (StackPtr >= StackSize)
  1858.                                 {
  1859.                                     StackElement*            NewStack;
  1860.  
  1861.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1862.                                         * sizeof(StackElement));
  1863.                                     if (NewStack == NIL)
  1864.                                         {
  1865.                                             StackPtr -= 1;
  1866.                                             ErrorCode = eEvalOutOfMemory;
  1867.                                             goto ExceptionPoint;
  1868.                                         }
  1869.                                     Stack = NewStack;
  1870.                                     StackSize += 8;
  1871.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1872.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadDoubleFromStack]: stack size inconsistency"));
  1873.                                 }
  1874.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1875.                             Stack[StackPtr].Data.Double = Stack[Index].Data.Double;
  1876.                             Stack[StackPtr].ElementType = esScalar;
  1877.                             ProgramCounter += 1;
  1878.                             break;
  1879.                         case epLoadArrayFromStack:
  1880.                             /*    -1         0    */
  1881.                             /* <opcode> <stackindex> */
  1882.                             PRNGCHK(CurrentProcedure,
  1883.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1884.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1885.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1886.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1887.                             ERROR(Stack[Index].ElementType != esArray,PRERR(ForceAbort,
  1888.                                 "EvaluatePcode [epLoadArrayFromStack]:  array slot of wrong type"));
  1889.                             StackPtr += 1;
  1890.                             if (StackPtr >= StackSize)
  1891.                                 {
  1892.                                     StackElement*            NewStack;
  1893.  
  1894.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1895.                                         * sizeof(StackElement));
  1896.                                     if (NewStack == NIL)
  1897.                                         {
  1898.                                             StackPtr -= 1;
  1899.                                             ErrorCode = eEvalOutOfMemory;
  1900.                                             goto ExceptionPoint;
  1901.                                         }
  1902.                                     Stack = NewStack;
  1903.                                     StackSize += 8;
  1904.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1905.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadArrayFromStack]: stack size inconsistency"));
  1906.                                 }
  1907.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1908.                             Stack[StackPtr].Data.Array = Stack[Index].Data.Array;
  1909.                             Stack[StackPtr].ElementType = esArray;
  1910.                             ProgramCounter += 1;
  1911.                             break;
  1912.  
  1913.                         case epStackPop:
  1914.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1915.                             if ((Stack[StackPtr].ElementType == esArray)
  1916.                                 && (Stack[StackPtr].Data.Array != NIL))
  1917.                                 {
  1918.                                     DisposeIfNotOnStack(Stack,StackPtr);
  1919.                                 }
  1920.                             StackPtr -= 1;
  1921.                             break;
  1922.  
  1923.                         case epStackAllocate:
  1924.                             StackPtr += 1;
  1925.                             if (StackPtr >= StackSize)
  1926.                                 {
  1927.                                     StackElement*            NewStack;
  1928.  
  1929.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1930.                                         * sizeof(StackElement));
  1931.                                     if (NewStack == NIL)
  1932.                                         {
  1933.                                             StackPtr -= 1;
  1934.                                             ErrorCode = eEvalOutOfMemory;
  1935.                                             goto ExceptionPoint;
  1936.                                         }
  1937.                                     Stack = NewStack;
  1938.                                     StackSize += 8;
  1939.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1940.                                         PRERR(ForceAbort,"EvaluatePcode [epStackAllocate]: stack size inconsistency"));
  1941.                                 }
  1942.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1943.                             Stack[StackPtr].ElementType = esScalar;
  1944.                             break;
  1945.  
  1946.                         case epStackPopMultiple:
  1947.                             /*     -1       0   */
  1948.                             /* <opcode> <numwords> */
  1949.                             PRNGCHK(CurrentProcedure,
  1950.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1951.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1952.                             Index = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1953.                             while (Index > 0)
  1954.                                 {
  1955.                                     PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1956.                                     if ((Stack[StackPtr].ElementType == esArray)
  1957.                                         && (Stack[StackPtr].Data.Array != NIL))
  1958.                                         {
  1959.                                             DisposeIfNotOnStack(Stack,StackPtr);
  1960.                                         }
  1961.                                     StackPtr -= 1;
  1962.                                     Index -= 1;
  1963.                                 }
  1964.                             ProgramCounter += 1;
  1965.                             break;
  1966.  
  1967.                         /* deallocate multiple cells under the current top */
  1968.                         case epStackDeallocateUnder:
  1969.                             /*    -1        0   */
  1970.                             /* <opcode> <numwords> */
  1971.                             PRNGCHK(CurrentProcedure,
  1972.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1973.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1974.                             /* get the number of cells to deallocate */
  1975.                             Index = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1976.                             while (Index > 0)
  1977.                                 {
  1978.                                     PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1979.                                     if ((Stack[StackPtr - 1].ElementType == esArray)
  1980.                                         && (Stack[StackPtr - 1].Data.Array != NIL))
  1981.                                         {
  1982.                                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  1983.                                         }
  1984.                                     PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1985.                                     Stack[StackPtr - 1] = Stack[StackPtr];
  1986.                                     StackPtr -= 1;
  1987.                                     Index -= 1;
  1988.                                 }
  1989.                             ProgramCounter += 1;
  1990.                             break;
  1991.  
  1992.                         /* duplicate the top word of the stack */
  1993.                         case epDuplicate:
  1994.                             StackPtr += 1;
  1995.                             if (StackPtr >= StackSize)
  1996.                                 {
  1997.                                     StackElement*            NewStack;
  1998.  
  1999.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2000.                                         * sizeof(StackElement));
  2001.                                     if (NewStack == NIL)
  2002.                                         {
  2003.                                             StackPtr -= 1;
  2004.                                             ErrorCode = eEvalOutOfMemory;
  2005.                                             goto ExceptionPoint;
  2006.                                         }
  2007.                                     Stack = NewStack;
  2008.                                     StackSize += 8;
  2009.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2010.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadDoubleFromStack]: stack size inconsistency"));
  2011.                                 }
  2012.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2013.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2014.                             Stack[StackPtr] = Stack[StackPtr - 1];
  2015.                             break;
  2016.  
  2017.                         /* no operation */
  2018.                         case epNop:
  2019.                             break;
  2020.  
  2021.                         /* new array allocation procedures */
  2022.                         case epMakeBooleanArray:
  2023.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2024.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2025.                                 "EvaluatePcode [epMakeBooleanArray]: bad stack element type"));
  2026.                             Index = Stack[StackPtr].Data.Integer;
  2027.                             Stack[StackPtr].Data.Array = AllocPtrCanFail(Index,"EvalPcodeBoolArray");
  2028.                             if (Stack[StackPtr].Data.Array == NIL)
  2029.                                 {
  2030.                                     ErrorCode = eEvalOutOfMemory;
  2031.                                     goto ExceptionPoint;
  2032.                                 }
  2033.                             Stack[StackPtr].ElementType = esArray;
  2034.                             for (Scan = 0; Scan < Index; Scan += 1)
  2035.                                 {
  2036.                                     PRNGCHK(Stack[StackPtr].Data.Array,
  2037.                                         &(((char*)(Stack[StackPtr].Data.Array))[Scan]),sizeof(char));
  2038.                                     ((char*)(Stack[StackPtr].Data.Array))[Scan] = 0;
  2039.                                 }
  2040.                             break;
  2041.                         case epMakeIntegerArray:
  2042.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2043.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2044.                                 "EvaluatePcode [epMakeIntegerArray]: bad stack element type"));
  2045.                             Index = Stack[StackPtr].Data.Integer;
  2046.                             Stack[StackPtr].Data.Array = AllocPtrCanFail(
  2047.                                 Index * sizeof(long),"EvalPcodeIntArray");
  2048.                             if (Stack[StackPtr].Data.Array == NIL)
  2049.                                 {
  2050.                                     ErrorCode = eEvalOutOfMemory;
  2051.                                     goto ExceptionPoint;
  2052.                                 }
  2053.                             Stack[StackPtr].ElementType = esArray;
  2054.                             for (Scan = 0; Scan < Index; Scan += 1)
  2055.                                 {
  2056.                                     PRNGCHK(Stack[StackPtr].Data.Array,
  2057.                                         &(((long*)(Stack[StackPtr].Data.Array))[Scan]),sizeof(long));
  2058.                                     ((long*)(Stack[StackPtr].Data.Array))[Scan] = 0;
  2059.                                 }
  2060.                             break;
  2061.                         case epMakeFloatArray:
  2062.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2063.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2064.                                 "EvaluatePcode [epMakeFloatArray]: bad stack element type"));
  2065.                             Index = Stack[StackPtr].Data.Integer;
  2066.                             Stack[StackPtr].Data.Array = AllocPtrCanFail(
  2067.                                 Index * sizeof(float),"EvalPcodeFloatArray");
  2068.                             if (Stack[StackPtr].Data.Array == NIL)
  2069.                                 {
  2070.                                     ErrorCode = eEvalOutOfMemory;
  2071.                                     goto ExceptionPoint;
  2072.                                 }
  2073.                             Stack[StackPtr].ElementType = esArray;
  2074.                             for (Scan = 0; Scan < Index; Scan += 1)
  2075.                                 {
  2076.                                     PRNGCHK(Stack[StackPtr].Data.Array,
  2077.                                         &(((float*)(Stack[StackPtr].Data.Array))[Scan]),sizeof(float));
  2078.                                     ((float*)(Stack[StackPtr].Data.Array))[Scan] = 0;
  2079.                                 }
  2080.                             break;
  2081.                         case epMakeDoubleArray:
  2082.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2083.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2084.                                 "EvaluatePcode [epMakeDoubleArray]: bad stack element type"));
  2085.                             Index = Stack[StackPtr].Data.Integer;
  2086.                             Stack[StackPtr].Data.Array = AllocPtrCanFail(
  2087.                                 Index * sizeof(double),"EvalPcodeDoubleArray");
  2088.                             if (Stack[StackPtr].Data.Array == NIL)
  2089.                                 {
  2090.                                     ErrorCode = eEvalOutOfMemory;
  2091.                                     goto ExceptionPoint;
  2092.                                 }
  2093.                             Stack[StackPtr].ElementType = esArray;
  2094.                             for (Scan = 0; Scan < Index; Scan += 1)
  2095.                                 {
  2096.                                     PRNGCHK(Stack[StackPtr].Data.Array,
  2097.                                         &(((double*)(Stack[StackPtr].Data.Array))[Scan]),
  2098.                                         sizeof(double));
  2099.                                     ((double*)(Stack[StackPtr].Data.Array))[Scan] = 0;
  2100.                                 }
  2101.                             break;
  2102.                         case epMakeFixedArray:
  2103.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2104.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2105.                                 "EvaluatePcode [epMakeFixedArray]: bad stack element type"));
  2106.                             Index = Stack[StackPtr].Data.Integer;
  2107.                             Stack[StackPtr].Data.Array = AllocPtrCanFail(
  2108.                                 Index * sizeof(long),"EvalPcodeFixedArray");
  2109.                             if (Stack[StackPtr].Data.Array == NIL)
  2110.                                 {
  2111.                                     ErrorCode = eEvalOutOfMemory;
  2112.                                     goto ExceptionPoint;
  2113.                                 }
  2114.                             Stack[StackPtr].ElementType = esArray;
  2115.                             for (Scan = 0; Scan < Index; Scan += 1)
  2116.                                 {
  2117.                                     PRNGCHK(Stack[StackPtr].Data.Array,
  2118.                                         &(((largefixedsigned*)(Stack[StackPtr].Data.Array))[Scan]),
  2119.                                         sizeof(largefixedsigned));
  2120.                                     ((largefixedsigned*)(Stack[StackPtr].Data.Array))[Scan] = 0;
  2121.                                 }
  2122.                             break;
  2123.  
  2124.                         case epStoreBooleanIntoArray2:
  2125.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2126.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2127.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2128.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2129.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2130.                                 "EvaluatePcode [epStoreBooleanIntoArray]: bad stack element type"));
  2131.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2132.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2133.                                 "EvaluatePcode [epStoreBooleanIntoArray]:  not an array"));
  2134.                             if (Stack[StackPtr - 1].Data.Array == NIL)
  2135.                                 {
  2136.                                     ErrorCode = eEvalArrayDoesntExist;
  2137.                                     goto ExceptionPoint;
  2138.                                 }
  2139.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2140.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.Array)))
  2141.                                 {
  2142.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2143.                                     goto ExceptionPoint;
  2144.                                 }
  2145.                             PRNGCHK(Stack[StackPtr - 1].Data.Array,
  2146.                                 &(((char*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]),
  2147.                                 sizeof(char));
  2148.                             ((char*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]
  2149.                                 = Stack[StackPtr - 2].Data.Integer;
  2150.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2151.                             StackPtr -= 2; /* pop subscript and reference */
  2152.                             break;
  2153.                         case epStoreIntegerIntoArray2:
  2154.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2155.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2156.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2157.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2158.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2159.                                 "EvaluatePcode [epStoreIntegerIntoArray]: bad stack element type"));
  2160.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2161.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2162.                                 "EvaluatePcode [epStoreIntegerIntoArray]:  not an array"));
  2163.                             if (Stack[StackPtr - 1].Data.Array == NIL)
  2164.                                 {
  2165.                                     ErrorCode = eEvalArrayDoesntExist;
  2166.                                     goto ExceptionPoint;
  2167.                                 }
  2168.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2169.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.Array) / sizeof(long)))
  2170.                                 {
  2171.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2172.                                     goto ExceptionPoint;
  2173.                                 }
  2174.                             PRNGCHK(Stack[StackPtr - 1].Data.Array,
  2175.                                 &(((long*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]),
  2176.                                 sizeof(long));
  2177.                             ((long*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]
  2178.                                 = Stack[StackPtr - 2].Data.Integer;
  2179.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2180.                             StackPtr -= 2; /* pop subscript and reference */
  2181.                             break;
  2182.                         case epStoreFloatIntoArray2:
  2183.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2184.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2185.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2186.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2187.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2188.                                 "EvaluatePcode [epStoreFloatIntoArray]: bad stack element type"));
  2189.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2190.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2191.                                 "EvaluatePcode [epStoreFloatIntoArray]:  not an array"));
  2192.                             if (Stack[StackPtr - 1].Data.Array == NIL)
  2193.                                 {
  2194.                                     ErrorCode = eEvalArrayDoesntExist;
  2195.                                     goto ExceptionPoint;
  2196.                                 }
  2197.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2198.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.Array) / sizeof(float)))
  2199.                                 {
  2200.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2201.                                     goto ExceptionPoint;
  2202.                                 }
  2203.                             PRNGCHK(Stack[StackPtr - 1].Data.Array,
  2204.                                 &(((float*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]),
  2205.                                 sizeof(float));
  2206.                             ((float*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]
  2207.                                 = Stack[StackPtr - 2].Data.Float;
  2208.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2209.                             StackPtr -= 2; /* pop subscript and reference */
  2210.                             break;
  2211.                         case epStoreDoubleIntoArray2:
  2212.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2213.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2214.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2215.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2216.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2217.                                 "EvaluatePcode [epStoreDoubleIntoArray]: bad stack element type"));
  2218.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2219.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2220.                                 "EvaluatePcode [epStoreDoubleIntoArray]:  not an array"));
  2221.                             if (Stack[StackPtr - 1].Data.Array == NIL)
  2222.                                 {
  2223.                                     ErrorCode = eEvalArrayDoesntExist;
  2224.                                     goto ExceptionPoint;
  2225.                                 }
  2226.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2227.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.Array) / sizeof(double)))
  2228.                                 {
  2229.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2230.                                     goto ExceptionPoint;
  2231.                                 }
  2232.                             PRNGCHK(Stack[StackPtr - 1].Data.Array,
  2233.                                 &(((double*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]),
  2234.                                 sizeof(double));
  2235.                             ((double*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]
  2236.                                 = Stack[StackPtr - 2].Data.Double;
  2237.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2238.                             StackPtr -= 2; /* pop subscript and reference */
  2239.                             break;
  2240.                         case epStoreFixedIntoArray2:
  2241.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2242.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2243.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2244.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2245.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2246.                                 "EvaluatePcode [epStoreFixedIntoArray]: bad stack element type"));
  2247.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2248.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2249.                                 "EvaluatePcode [epStoreFixedIntoArray]:  not an array"));
  2250.                             if (Stack[StackPtr - 1].Data.Array == NIL)
  2251.                                 {
  2252.                                     ErrorCode = eEvalArrayDoesntExist;
  2253.                                     goto ExceptionPoint;
  2254.                                 }
  2255.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2256.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.Array)
  2257.                                 / sizeof(largefixedsigned)))
  2258.                                 {
  2259.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2260.                                     goto ExceptionPoint;
  2261.                                 }
  2262.                             PRNGCHK(Stack[StackPtr - 1].Data.Array,
  2263.                                 &(((largefixedsigned*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]),
  2264.                                 sizeof(largefixedsigned));
  2265.                             ((largefixedsigned*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]
  2266.                                 = Stack[StackPtr - 2].Data.Integer;
  2267.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2268.                             StackPtr -= 2; /* pop subscript and reference */
  2269.                             break;
  2270.  
  2271.                         case epLoadBooleanFromArray2:
  2272.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2273.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2274.                                 "EvaluatePcode [epLoadBooleanFromArray]: bad stack element type"));
  2275.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2276.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2277.                                 "EvaluatePcode [epLoadBooleanFromArray]:  not an array"));
  2278.                             if (Stack[StackPtr - 1].Data.Array == NIL)
  2279.                                 {
  2280.                                     ErrorCode = eEvalArrayDoesntExist;
  2281.                                     goto ExceptionPoint;
  2282.                                 }
  2283.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2284.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.Array)))
  2285.                                 {
  2286.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2287.                                     goto ExceptionPoint;
  2288.                                 }
  2289.                             PRNGCHK(Stack[StackPtr - 1].Data.Array,
  2290.                                 &(((char*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]),
  2291.                                 sizeof(char));
  2292.                             {
  2293.                                 long                        BoolTemp;
  2294.  
  2295.                                 BoolTemp = ((char*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr]
  2296.                                     .Data.Integer];
  2297.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2298.                                 StackPtr -= 1;
  2299.                                 Stack[StackPtr].ElementType = esScalar;
  2300.                                 Stack[StackPtr].Data.Integer = BoolTemp;
  2301.                             }
  2302.                             break;
  2303.                         case epLoadIntegerFromArray2:
  2304.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2305.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2306.                                 "EvaluatePcode [epLoadIntegerFromArray]: bad stack element type"));
  2307.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2308.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2309.                                 "EvaluatePcode [epLoadIntegerFromArray]:  not an array"));
  2310.                             if (Stack[StackPtr - 1].Data.Array == NIL)
  2311.                                 {
  2312.                                     ErrorCode = eEvalArrayDoesntExist;
  2313.                                     goto ExceptionPoint;
  2314.                                 }
  2315.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2316.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.Array) / sizeof(long)))
  2317.                                 {
  2318.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2319.                                     goto ExceptionPoint;
  2320.                                 }
  2321.                             PRNGCHK(Stack[StackPtr - 1].Data.Array,
  2322.                                 &(((long*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]),
  2323.                                 sizeof(long));
  2324.                             {
  2325.                                 long                        IntegerTemp;
  2326.  
  2327.                                 IntegerTemp = ((long*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr]
  2328.                                     .Data.Integer];
  2329.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2330.                                 StackPtr -= 1;
  2331.                                 Stack[StackPtr].ElementType = esScalar;
  2332.                                 Stack[StackPtr].Data.Integer = IntegerTemp;
  2333.                             }
  2334.                             break;
  2335.                         case epLoadFloatFromArray2:
  2336.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2337.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2338.                                 "EvaluatePcode [epLoadFloatFromArray]: bad stack element type"));
  2339.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2340.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2341.                                 "EvaluatePcode [epLoadFloatFromArray]:  not an array"));
  2342.                             if (Stack[StackPtr - 1].Data.Array == NIL)
  2343.                                 {
  2344.                                     ErrorCode = eEvalArrayDoesntExist;
  2345.                                     goto ExceptionPoint;
  2346.                                 }
  2347.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2348.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.Array) / sizeof(float)))
  2349.                                 {
  2350.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2351.                                     goto ExceptionPoint;
  2352.                                 }
  2353.                             PRNGCHK(Stack[StackPtr - 1].Data.Array,
  2354.                                 &(((float*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]),
  2355.                                 sizeof(float));
  2356.                             {
  2357.                                 float                        FloatTemp;
  2358.  
  2359.                                 FloatTemp = ((float*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr]
  2360.                                     .Data.Integer];
  2361.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2362.                                 StackPtr -= 1;
  2363.                                 Stack[StackPtr].ElementType = esScalar;
  2364.                                 Stack[StackPtr].Data.Float = FloatTemp;
  2365.                             }
  2366.                             break;
  2367.                         case epLoadDoubleFromArray2:
  2368.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2369.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2370.                                 "EvaluatePcode [epLoadDoubleFromArray]: bad stack element type"));
  2371.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2372.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2373.                                 "EvaluatePcode [epLoadDoubleFromArray]:  not an array"));
  2374.                             if (Stack[StackPtr - 1].Data.Array == NIL)
  2375.                                 {
  2376.                                     ErrorCode = eEvalArrayDoesntExist;
  2377.                                     goto ExceptionPoint;
  2378.                                 }
  2379.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2380.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.Array) / sizeof(double)))
  2381.                                 {
  2382.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2383.                                     goto ExceptionPoint;
  2384.                                 }
  2385.                             PRNGCHK(Stack[StackPtr - 1].Data.Array,
  2386.                                 &(((double*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr].Data.Integer]),
  2387.                                 sizeof(double));
  2388.                             {
  2389.                                 double                        DoubleTemp;
  2390.  
  2391.                                 DoubleTemp = ((double*)(Stack[StackPtr - 1].Data.Array))[Stack[StackPtr]
  2392.                                     .Data.Integer];
  2393.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2394.                                 StackPtr -= 1;
  2395.                                 Stack[StackPtr].ElementType = esScalar;
  2396.                                 Stack[StackPtr].Data.Double = DoubleTemp;
  2397.                             }
  2398.                             break;
  2399.                         case epLoadFixedFromArray2:
  2400.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2401.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2402.                                 "EvaluatePcode [epLoadFixedFromArray]: bad stack element type"));
  2403.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2404.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2405.                                 "EvaluatePcode [epLoadFixedFromArray]:  not an array"));
  2406.                             if (Stack[StackPtr - 1].Data.Array == NIL)
  2407.                                 {
  2408.                                     ErrorCode = eEvalArrayDoesntExist;
  2409.                                     goto ExceptionPoint;
  2410.                                 }
  2411.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2412.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.Array)
  2413.                                 / sizeof(largefixedsigned)))
  2414.                                 {
  2415.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2416.                                     goto ExceptionPoint;
  2417.                                 }
  2418.                             PRNGCHK(Stack[StackPtr - 1].Data.Array,
  2419.                                 &(((largefixedsigned*)(Stack[StackPtr - 1].Data.Array))
  2420.                                 [Stack[StackPtr].Data.Integer]),sizeof(largefixedsigned));
  2421.                             {
  2422.                                 largefixedsigned        FixedTemp;
  2423.  
  2424.                                 FixedTemp = ((largefixedsigned*)(Stack[StackPtr - 1].Data
  2425.                                     .Array))[Stack[StackPtr].Data.Integer];
  2426.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2427.                                 StackPtr -= 1;
  2428.                                 Stack[StackPtr].ElementType = esScalar;
  2429.                                 Stack[StackPtr].Data.Integer = FixedTemp;
  2430.                             }
  2431.                             break;
  2432.  
  2433.                         /* load immediate values */
  2434.                         case epLoadImmediateInteger:
  2435.                             /*    -1        0   */
  2436.                             /* <opcode> <integer>; also used for boolean & fixed */
  2437.                             StackPtr += 1;
  2438.                             if (StackPtr >= StackSize)
  2439.                                 {
  2440.                                     StackElement*            NewStack;
  2441.  
  2442.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2443.                                         * sizeof(StackElement));
  2444.                                     if (NewStack == NIL)
  2445.                                         {
  2446.                                             StackPtr -= 1;
  2447.                                             ErrorCode = eEvalOutOfMemory;
  2448.                                             goto ExceptionPoint;
  2449.                                         }
  2450.                                     Stack = NewStack;
  2451.                                     StackSize += 8;
  2452.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2453.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2454.                                 }
  2455.                             PRNGCHK(CurrentProcedure,
  2456.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  2457.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  2458.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2459.                             Stack[StackPtr].Data.Integer
  2460.                                 = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  2461.                             Stack[StackPtr].ElementType = esScalar;
  2462.                             ProgramCounter += 1;
  2463.                             break;
  2464.                         case epLoadImmediateFloat:
  2465.                             /*    -1        0   */
  2466.                             /* <opcode> <integer>; also used for boolean & fixed */
  2467.                             StackPtr += 1;
  2468.                             if (StackPtr >= StackSize)
  2469.                                 {
  2470.                                     StackElement*            NewStack;
  2471.  
  2472.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2473.                                         * sizeof(StackElement));
  2474.                                     if (NewStack == NIL)
  2475.                                         {
  2476.                                             StackPtr -= 1;
  2477.                                             ErrorCode = eEvalOutOfMemory;
  2478.                                             goto ExceptionPoint;
  2479.                                         }
  2480.                                     Stack = NewStack;
  2481.                                     StackSize += 8;
  2482.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2483.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2484.                                 }
  2485.                             PRNGCHK(CurrentProcedure,
  2486.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateFloat),
  2487.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateFloat));
  2488.                             PRNGCHK(CurrentProcedure[ProgramCounter + 0].ImmediateFloat,
  2489.                                 &(*(CurrentProcedure[ProgramCounter + 0].ImmediateFloat)),sizeof(float));
  2490.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2491.                             Stack[StackPtr].Data.Float
  2492.                                 = *(CurrentProcedure[ProgramCounter + 0].ImmediateFloat);
  2493.                             Stack[StackPtr].ElementType = esScalar;
  2494.                             ProgramCounter += 1;
  2495.                             break;
  2496.                         case epLoadImmediateDouble:
  2497.                             /*    -1        0   */
  2498.                             /* <opcode> <integer>; also used for boolean & fixed */
  2499.                             StackPtr += 1;
  2500.                             if (StackPtr >= StackSize)
  2501.                                 {
  2502.                                     StackElement*            NewStack;
  2503.  
  2504.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2505.                                         * sizeof(StackElement));
  2506.                                     if (NewStack == NIL)
  2507.                                         {
  2508.                                             StackPtr -= 1;
  2509.                                             ErrorCode = eEvalOutOfMemory;
  2510.                                             goto ExceptionPoint;
  2511.                                         }
  2512.                                     Stack = NewStack;
  2513.                                     StackSize += 8;
  2514.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2515.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2516.                                 }
  2517.                             PRNGCHK(CurrentProcedure,
  2518.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateDouble),
  2519.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateDouble));
  2520.                             PRNGCHK(CurrentProcedure[ProgramCounter + 0].ImmediateDouble,
  2521.                                 &(*(CurrentProcedure[ProgramCounter + 0].ImmediateDouble)),
  2522.                                 sizeof(double));
  2523.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2524.                             Stack[StackPtr].Data.Double
  2525.                                 = *(CurrentProcedure[ProgramCounter + 0].ImmediateDouble);
  2526.                             Stack[StackPtr].ElementType = esScalar;
  2527.                             ProgramCounter += 1;
  2528.                             break;
  2529.                         case epLoadImmediateNILArray:
  2530.                             /* <opcode> */
  2531.                             StackPtr += 1;
  2532.                             if (StackPtr >= StackSize)
  2533.                                 {
  2534.                                     StackElement*            NewStack;
  2535.  
  2536.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2537.                                         * sizeof(StackElement));
  2538.                                     if (NewStack == NIL)
  2539.                                         {
  2540.                                             StackPtr -= 1;
  2541.                                             ErrorCode = eEvalOutOfMemory;
  2542.                                             goto ExceptionPoint;
  2543.                                         }
  2544.                                     Stack = NewStack;
  2545.                                     StackSize += 8;
  2546.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2547.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2548.                                 }
  2549.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2550.                             Stack[StackPtr].Data.Array = NIL;
  2551.                             Stack[StackPtr].ElementType = esArray;
  2552.                             break;
  2553.  
  2554.                         case epGetSampleLeftArray:
  2555.                             /*    -1           0    */
  2556.                             /* <opcode> ^"<namestring>" */
  2557.                             StackPtr += 1;
  2558.                             if (StackPtr >= StackSize)
  2559.                                 {
  2560.                                     StackElement*            NewStack;
  2561.  
  2562.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2563.                                         * sizeof(StackElement));
  2564.                                     if (NewStack == NIL)
  2565.                                         {
  2566.                                             StackPtr -= 1;
  2567.                                             ErrorCode = eEvalOutOfMemory;
  2568.                                             goto ExceptionPoint;
  2569.                                         }
  2570.                                     Stack = NewStack;
  2571.                                     StackSize += 8;
  2572.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2573.                                         PRERR(ForceAbort,"EvaluatePcode [epGetSampleLeftArray]: stack size inconsistency"));
  2574.                                 }
  2575.                             PRNGCHK(CurrentProcedure,
  2576.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2577.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2578.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2579.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2580.                             switch ((*GetSampleLeftCopy)(Refcon,CurrentProcedure[
  2581.                                 ProgramCounter + 0].ImmediateString,
  2582.                                 (largefixedsigned**)&(Stack[StackPtr].Data.Array)))
  2583.                                 {
  2584.                                     case eEvalSampleNoError:
  2585.                                         CheckPtrExistence(Stack[StackPtr].Data.Array);
  2586.                                         Stack[StackPtr].ElementType = esArray;
  2587.                                         break;
  2588.                                     case eEvalSampleUndefined:
  2589.                                         ErrorCode = eEvalGetSampleNotDefined;
  2590.                                         goto ExceptionPoint;
  2591.                                     case eEvalSampleWrongChannel:
  2592.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2593.                                         goto ExceptionPoint;
  2594.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2595.                                         ErrorCode = eEvalOutOfMemory;
  2596.                                         goto ExceptionPoint;
  2597.                                     default:
  2598.                                         EXECUTE(PRERR(ForceAbort,
  2599.                                             "EvaluatePcode [epGetSampleLeftArray]: unknown return code"));
  2600.                                         break;
  2601.                                 }
  2602.                             ProgramCounter += 1;
  2603.                             break;
  2604.                         case epGetSampleRightArray:
  2605.                             /*    -1           0    */
  2606.                             /* <opcode> ^"<namestring>" */
  2607.                             StackPtr += 1;
  2608.                             if (StackPtr >= StackSize)
  2609.                                 {
  2610.                                     StackElement*            NewStack;
  2611.  
  2612.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2613.                                         * sizeof(StackElement));
  2614.                                     if (NewStack == NIL)
  2615.                                         {
  2616.                                             StackPtr -= 1;
  2617.                                             ErrorCode = eEvalOutOfMemory;
  2618.                                             goto ExceptionPoint;
  2619.                                         }
  2620.                                     Stack = NewStack;
  2621.                                     StackSize += 8;
  2622.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2623.                                         PRERR(ForceAbort,"EvaluatePcode [epGetSampleRightArray]: stack size inconsistency"));
  2624.                                 }
  2625.                             PRNGCHK(CurrentProcedure,
  2626.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2627.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2628.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2629.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2630.                             switch ((*GetSampleRightCopy)(Refcon,CurrentProcedure[
  2631.                                 ProgramCounter + 0].ImmediateString,
  2632.                                 (largefixedsigned**)&(Stack[StackPtr].Data.Array)))
  2633.                                 {
  2634.                                     case eEvalSampleNoError:
  2635.                                         CheckPtrExistence(Stack[StackPtr].Data.Array);
  2636.                                         Stack[StackPtr].ElementType = esArray;
  2637.                                         break;
  2638.                                     case eEvalSampleUndefined:
  2639.                                         ErrorCode = eEvalGetSampleNotDefined;
  2640.                                         goto ExceptionPoint;
  2641.                                     case eEvalSampleWrongChannel:
  2642.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2643.                                         goto ExceptionPoint;
  2644.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2645.                                         ErrorCode = eEvalOutOfMemory;
  2646.                                         goto ExceptionPoint;
  2647.                                     default:
  2648.                                         EXECUTE(PRERR(ForceAbort,
  2649.                                             "EvaluatePcode [epGetSampleRightArray]: unknown return code"));
  2650.                                         break;
  2651.                                 }
  2652.                             ProgramCounter += 1;
  2653.                             break;
  2654.                         case epGetSampleMonoArray:
  2655.                             /*    -1           0    */
  2656.                             /* <opcode> ^"<namestring>" */
  2657.                             StackPtr += 1;
  2658.                             if (StackPtr >= StackSize)
  2659.                                 {
  2660.                                     StackElement*            NewStack;
  2661.  
  2662.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2663.                                         * sizeof(StackElement));
  2664.                                     if (NewStack == NIL)
  2665.                                         {
  2666.                                             StackPtr -= 1;
  2667.                                             ErrorCode = eEvalOutOfMemory;
  2668.                                             goto ExceptionPoint;
  2669.                                         }
  2670.                                     Stack = NewStack;
  2671.                                     StackSize += 8;
  2672.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2673.                                         PRERR(ForceAbort,"EvaluatePcode [epGetSampleMonoArray]: stack size inconsistency"));
  2674.                                 }
  2675.                             PRNGCHK(CurrentProcedure,
  2676.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2677.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2678.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2679.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2680.                             switch ((*GetSampleMiddleCopy)(Refcon,CurrentProcedure[
  2681.                                 ProgramCounter + 0].ImmediateString,
  2682.                                 (largefixedsigned**)&(Stack[StackPtr].Data.Array)))
  2683.                                 {
  2684.                                     case eEvalSampleNoError:
  2685.                                         CheckPtrExistence(Stack[StackPtr].Data.Array);
  2686.                                         Stack[StackPtr].ElementType = esArray;
  2687.                                         break;
  2688.                                     case eEvalSampleUndefined:
  2689.                                         ErrorCode = eEvalGetSampleNotDefined;
  2690.                                         goto ExceptionPoint;
  2691.                                     case eEvalSampleWrongChannel:
  2692.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2693.                                         goto ExceptionPoint;
  2694.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2695.                                         ErrorCode = eEvalOutOfMemory;
  2696.                                         goto ExceptionPoint;
  2697.                                     default:
  2698.                                         EXECUTE(PRERR(ForceAbort,
  2699.                                             "EvaluatePcode [epGetSampleMonoArray]: unknown return code"));
  2700.                                         break;
  2701.                                 }
  2702.                             ProgramCounter += 1;
  2703.                             break;
  2704.                         case epGetWaveTableArray:
  2705.                             /*    -1           0    */
  2706.                             /* <opcode> ^"<namestring>" */
  2707.                             StackPtr += 1;
  2708.                             if (StackPtr >= StackSize)
  2709.                                 {
  2710.                                     StackElement*            NewStack;
  2711.  
  2712.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2713.                                         * sizeof(StackElement));
  2714.                                     if (NewStack == NIL)
  2715.                                         {
  2716.                                             StackPtr -= 1;
  2717.                                             ErrorCode = eEvalOutOfMemory;
  2718.                                             goto ExceptionPoint;
  2719.                                         }
  2720.                                     Stack = NewStack;
  2721.                                     StackSize += 8;
  2722.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2723.                                         PRERR(ForceAbort,"EvaluatePcode [epGetWaveTableArray]: stack size inconsistency"));
  2724.                                 }
  2725.                             PRNGCHK(CurrentProcedure,
  2726.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2727.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2728.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2729.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2730.                             switch ((*GetWaveTableCopy)(Refcon,CurrentProcedure[
  2731.                                 ProgramCounter + 0].ImmediateString,
  2732.                                 (largefixedsigned**)&(Stack[StackPtr].Data.Array)))
  2733.                                 {
  2734.                                     case eEvalSampleNoError:
  2735.                                         CheckPtrExistence(Stack[StackPtr].Data.Array);
  2736.                                         Stack[StackPtr].ElementType = esArray;
  2737.                                         break;
  2738.                                     case eEvalSampleUndefined:
  2739.                                         ErrorCode = eEvalGetSampleNotDefined;
  2740.                                         goto ExceptionPoint;
  2741.                                     case eEvalSampleWrongChannel:
  2742.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2743.                                         goto ExceptionPoint;
  2744.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2745.                                         ErrorCode = eEvalOutOfMemory;
  2746.                                         goto ExceptionPoint;
  2747.                                     default:
  2748.                                         EXECUTE(PRERR(ForceAbort,
  2749.                                             "EvaluatePcode [epGetWaveTableArray]: unknown return code"));
  2750.                                         break;
  2751.                                 }
  2752.                             ProgramCounter += 1;
  2753.                             break;
  2754.                         case epGetWaveTableFrames:
  2755.                             /*    -1           0    */
  2756.                             /* <opcode> ^"<namestring>" */
  2757.                             StackPtr += 1;
  2758.                             if (StackPtr >= StackSize)
  2759.                                 {
  2760.                                     StackElement*            NewStack;
  2761.  
  2762.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2763.                                         * sizeof(StackElement));
  2764.                                     if (NewStack == NIL)
  2765.                                         {
  2766.                                             StackPtr -= 1;
  2767.                                             ErrorCode = eEvalOutOfMemory;
  2768.                                             goto ExceptionPoint;
  2769.                                         }
  2770.                                     Stack = NewStack;
  2771.                                     StackSize += 8;
  2772.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2773.                                         PRERR(ForceAbort,"EvaluatePcode [epGetWaveTableFrames]: stack size inconsistency"));
  2774.                                 }
  2775.                             PRNGCHK(CurrentProcedure,
  2776.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2777.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2778.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2779.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2780.                             switch ((*GetWaveTableFrameCount)(Refcon,CurrentProcedure[
  2781.                                 ProgramCounter + 0].ImmediateString,&(Stack[StackPtr].Data.Integer)))
  2782.                                 {
  2783.                                     case eEvalSampleNoError:
  2784.                                         Stack[StackPtr].ElementType = esScalar;
  2785.                                         break;
  2786.                                     case eEvalSampleUndefined:
  2787.                                         ErrorCode = eEvalGetSampleNotDefined;
  2788.                                         goto ExceptionPoint;
  2789.                                     case eEvalSampleWrongChannel:
  2790.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2791.                                         goto ExceptionPoint;
  2792.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2793.                                         ErrorCode = eEvalOutOfMemory;
  2794.                                         goto ExceptionPoint;
  2795.                                     default:
  2796.                                         EXECUTE(PRERR(ForceAbort,
  2797.                                             "EvaluatePcode [epGetWaveTableFrames]: unknown return code"));
  2798.                                         break;
  2799.                                 }
  2800.                             ProgramCounter += 1;
  2801.                             break;
  2802.                         case epGetWaveTableTables:
  2803.                             /*    -1           0    */
  2804.                             /* <opcode> ^"<namestring>" */
  2805.                             StackPtr += 1;
  2806.                             if (StackPtr >= StackSize)
  2807.                                 {
  2808.                                     StackElement*            NewStack;
  2809.  
  2810.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2811.                                         * sizeof(StackElement));
  2812.                                     if (NewStack == NIL)
  2813.                                         {
  2814.                                             StackPtr -= 1;
  2815.                                             ErrorCode = eEvalOutOfMemory;
  2816.                                             goto ExceptionPoint;
  2817.                                         }
  2818.                                     Stack = NewStack;
  2819.                                     StackSize += 8;
  2820.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2821.                                         PRERR(ForceAbort,"EvaluatePcode [epGetWaveTableTables]: stack size inconsistency"));
  2822.                                 }
  2823.                             PRNGCHK(CurrentProcedure,
  2824.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2825.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2826.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2827.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2828.                             switch ((*GetWaveTableTableCount)(Refcon,CurrentProcedure[
  2829.                                 ProgramCounter + 0].ImmediateString,&(Stack[StackPtr].Data.Integer)))
  2830.                                 {
  2831.                                     case eEvalSampleNoError:
  2832.                                         Stack[StackPtr].ElementType = esScalar;
  2833.                                         break;
  2834.                                     case eEvalSampleUndefined:
  2835.                                         ErrorCode = eEvalGetSampleNotDefined;
  2836.                                         goto ExceptionPoint;
  2837.                                     case eEvalSampleWrongChannel:
  2838.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2839.                                         goto ExceptionPoint;
  2840.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2841.                                         ErrorCode = eEvalOutOfMemory;
  2842.                                         goto ExceptionPoint;
  2843.                                     default:
  2844.                                         EXECUTE(PRERR(ForceAbort,
  2845.                                             "EvaluatePcode [epGetWaveTableTables]: unknown return code"));
  2846.                                         break;
  2847.                                 }
  2848.                             ProgramCounter += 1;
  2849.                             break;
  2850.  
  2851.                     } /* end switch */
  2852.             } /* end while */
  2853.  
  2854.  
  2855.         /* when something bad happens, set the ErrorCode with the error code and */
  2856.         /* jump here.  this will release all allocated arrays on the stack and in */
  2857.         /* the registers, set the offending function pcode, and return */
  2858.      ExceptionPoint:
  2859.         /* first, release all objects */
  2860.         while (StackPtr != GetStackNumElements(Prep) - 1)
  2861.             {
  2862.                 /* pop all elements except those that were there originally */
  2863.                 if ((Stack[StackPtr].ElementType == esArray)
  2864.                     && (Stack[StackPtr].Data.Array != NIL))
  2865.                     {
  2866.                         DisposeIfNotOnStack(Stack,StackPtr);
  2867.                     }
  2868.                 StackPtr -= 1;
  2869.             }
  2870.         /* then set up the error values */
  2871.         *OffendingPcode = CurrentProcedure;
  2872.         *OffendingInstruction = ProgramCounter - 1;
  2873.         /* write back values that might have changed */
  2874.         SetStackInformation(Prep,StackSize,StackPtr + 1,Stack);
  2875.         return ErrorCode;
  2876.  
  2877.  
  2878.         /* when execution finishes, jump here.  The lowest element [0] in the stack will */
  2879.         /* have the return value, placed there according to calling conventions */
  2880.      TotallyDonePoint:
  2881.         /* check stack pointer */
  2882.         ERROR(StackPtr != GetStackNumElements(Prep) - 1,PRERR(ForceAbort,
  2883.             "EvaluatePcode:  normal exit, but final stack pointer != initial stack pointer"));
  2884.         /* write back values that might have changed */
  2885.         SetStackInformation(Prep,StackSize,StackPtr + 1,Stack);
  2886.         /* return message that indicates everything went fine */
  2887.         return eEvalNoError;
  2888.     }
  2889.  
  2890.  
  2891. char*                            GetPcodeErrorMessage(EvalErrors Error)
  2892.     {
  2893.         char*                        ErrorString;
  2894.  
  2895.         switch (Error)
  2896.             {
  2897.                 default:
  2898.                     EXECUTE(PRERR(ForceAbort,"GetPcodeErrorMessage:  unknown error code"));
  2899.                     break;
  2900.                 case eEvalUndefinedFunction:
  2901.                     ErrorString = "Called an undefined function.";
  2902.                     break;
  2903.                 case eEvalErrorTrapEncountered:
  2904.                     ErrorString = "Error trap encountered; user cancelled execution.";
  2905.                     break;
  2906.                 case eEvalUserCancelled:
  2907.                     ErrorString = "User cancelled.";
  2908.                     break;
  2909.                 case eEvalDivideByZero:
  2910.                     ErrorString = "Divide by zero.";
  2911.                     break;
  2912.                 case eEvalOutOfMemory:
  2913.                     ErrorString = "Out of memory.";
  2914.                     break;
  2915.                 case eEvalArrayDoesntExist:
  2916.                     ErrorString = "Use of unallocated (NIL) array.";
  2917.                     break;
  2918.                 case eEvalArraySubscriptOutOfRange:
  2919.                     ErrorString = "Array subscript out of range.";
  2920.                     break;
  2921.                 case eEvalGetSampleNotDefined:
  2922.                     ErrorString = "Attempt to access undefined sample or wave table.";
  2923.                     break;
  2924.                 case eEvalGetSampleWrongChannelType:
  2925.                     ErrorString = "Attempt to load sample array with wrong channel type.";
  2926.                     break;
  2927.                 case eEvalWrongNumParametersForFunction:
  2928.                     ErrorString = "Wrong number of parameters for function call.";
  2929.                     break;
  2930.                 case eEvalWrongParameterType:
  2931.                     ErrorString = "Parameter for function call does not match function's type.";
  2932.                     break;
  2933.                 case eEvalWrongReturnType:
  2934.                     ErrorString = "Return type for function call does not match function's type.";
  2935.                     break;
  2936.             }
  2937.         return ErrorString;
  2938.     }
  2939.